Author SHA1 Message Date
Оля Мороз 66dffa5346 feat:fix
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-10 12:33:19 +03:00
Оля Мороз 692cfec080 feat:report
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-09 17:22:18 +03:00
Оля Мороз 9773639f52 feat:some_improvement 2026-10-07 17:33:29 +03:00
Оля Мороз 828a9f792a feat:level4 2026-10-01 16:53:27 +03:00
Оля Мороз 9febc0bbe4 feat:lab1-catchup 2026-10-01 10:55:28 +03:00
55 changed files with 2419 additions and 18 deletions
+2
View File
@@ -18,3 +18,5 @@ __pycache__
node_modules
evidence
.DS_Store
*.md
Makefile
+31
View File
@@ -0,0 +1,31 @@
# --- build stage ---
FROM golang:1.22-alpine AS build
WORKDIR /src
RUN apk add --no-cache ca-certificates
COPY go.mod go.sum ./
RUN go mod download
COPY cmd ./cmd
COPY src ./src
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/messenger
# --- runtime stage ---
FROM alpine:3.20
RUN apk add --no-cache ca-certificates postgresql-client && \
addgroup -S app && adduser -S -G app app
WORKDIR /app
COPY --from=build /out/messenger /app/messenger
COPY migrations /app/migrations
COPY scripts/migrate.sh /app/migrate.sh
RUN chmod +x /app/migrate.sh
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=5 \
CMD wget -qO- http://127.0.0.1:8080/health/live >/dev/null || exit 1
ENTRYPOINT ["/app/messenger"]
+16
View File
@@ -24,3 +24,19 @@ 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)
TMP_TTL ?= 2
my_tests_expiry:
COMPOSE_ENV_FILE="$(or $(COMPOSE_ENV_FILE),.env)" \
COMPOSE_FILE="$(or $(COMPOSE_FILE),compose.yaml)" \
$(PYTHON) student_tests/lab2_expiry.py \
--base-url "$(BASE_URL)" --ttl "$(TMP_TTL)" $(TLS_ARGS)
my_tests_extra:
COMPOSE_ENV_FILE="$(or $(COMPOSE_ENV_FILE),.env)" \
COMPOSE_FILE="$(or $(COMPOSE_FILE),compose.yaml)" \
$(PYTHON) student_tests/lab2_extra.py \
--base-url "$(BASE_URL)" $(TLS_ARGS)
my_tests: my_tests_expiry my_tests_extra
+241 -18
View File
@@ -1,37 +1,260 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Морозова Ольга Андреевна, БВТ2303
- Целевая оценка: **5**
- Выбранный трек 5: **Трек 2. План запроса и восстановление.**
- Репозиторий: [Gitea](https://gitea.privcloud.tech/MiniLynx/mtusi2026lab2-fork)
- PR: TODO после публикации
- Использованные источники: [README.md](README.md), [COURSE.md](COURSE.md), [contracts/openapi.json](contracts/openapi.json), [contracts/README.md](contracts/README.md), документация Go, PostgreSQL, Redis, Docker
- Библиотеки: Go 1.22 (stdlib), github.com/google/uuid v1.6.0, github.com/jackc/pgx/v5 v5.5.5, github.com/redis/go-redis/v9 v9.5.1, golang.org/x/crypto v0.23.0 (Argon2id). Тесты — Python 3 (stdlib).
- Помощь ИИ: Deepseek — написание и проверка кода.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Команды выполнялись в WSL2 (Ubuntu) на Windows 11.
Требования: Docker 24+ (Compose v2), Go 1.22+ (только для локальной сборки без Docker), Python 3.9+ (для тестов), make, `psql` при работе с треком 2 напрямую.
Версии (фиксированные теги образов):
- `golang:1.22-alpine` — build stage
- `alpine:3.20` — runtime stage
- `postgres:16.3-alpine`
- `redis:7.2.5-alpine`
### Подготовка
```sh
git clone https://gitea.privcloud.tech/MiniLynx/mtusi2026lab2-fork
cd mtusi2026lab2-fork
# 1. Секреты. В репозиторий они НЕ входят (см. .gitignore).
mkdir -p secrets
printf 'local-dev-postgres-password\n' > secrets/postgres_password.txt
printf 'postgres://messenger:local-dev-postgres-password@postgres:5432/messenger?sslmode=disable\n' \
> secrets/database_url.txt
printf 'redis://redis:6379/0\n' > secrets/cache_url.txt
# 2. Локальный .env на основе .env.example.
cp .env.example .env
# 3. Python для проверок.
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements-dev.txt
```
### Сборка и запуск
```sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# Дождаться /health/ready
docker compose ps
```
### Тесты
```sh
make check
make validate PYTHON=.venv/bin/python
make test
# Persistence (lab2+)
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Собственные проверки lab2
make my_tests
```
### Остановка (с сохранением volumes)
```sh
docker compose --env-file .env down
```
### Намеренное удаление учебных данных (НЕ использовать в persistence-проверках)
```sh
docker compose --env-file .env down -v
rm -f secrets/*.txt
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```text
HTTP-клиент → API (Go, net/http, PID 1, non-root app:app)
├── PostgreSQL 16.3 ─ users, chats, chat_members, messages, sessions
└── Redis 7.2.5 ─ кэш сессий (source of truth — PostgreSQL)
```
- **Источник истины:** PostgreSQL. Redis — только кэш; при его недоступности API продолжает работать через БД (проверяется в `lab2_extra.py`).
- **Транзакционные границы:**
- `CreateChat` — `BEGIN ... COMMIT` (Read Committed): проверка существования всех `member_ids`, вставка `chats`, вставка `chat_members`. При неизвестном участнике — rollback, наружу `ErrInvalid` → 400.
- `AddMessage` — `BEGIN ... COMMIT`: проверка членства + вставка сообщения.
- **Пароли:** Argon2id (PHC-строка, `m=19456, t=2, p=1`, 16-байтная соль, 32-байтный ключ), OWASP baseline. Сравнение — `subtle.ConstantTimeCompare`. При отсутствии пользователя всё равно выполняется фиктивный verify, чтобы не различать таймингом «нет пользователя» и «неверный пароль».
- **Сессии:** opaque-токен, 32 случайных байта (`crypto/rand`), `base64.RawURLEncoding` → 43 символа, ≥256 бит. Хранится в `sessions(token, user_id, expires_at)`. Кэш в Redis ключом `session:<token>`, TTL = остаток до `expires_at`.
- **Graceful shutdown:** SIGTERM/SIGINT, `srv.Shutdown(ctx)` с 10-секундным бюджетом.
- **Пул соединений:** `MaxConns=10`, `MinConns=1`, `ConnectTimeout=5s`, `MaxConnIdleTime=5m`, `MaxConnLifetime=1h`.
- **Кэш Redis:** `DialTimeout=1s`, `ReadTimeout=500ms`, `WriteTimeout=500ms`, `MaxRetries=0` — при недоступности сразу идём в БД, чтобы не блокировать клиента.
### Что перенесено из lab1
- Структура пакетов `src/api`, `src/domain`, `src/config`, `cmd/messenger`.
- Формат ошибок и `X-Request-Id`.
- Маршрутизация на `net/http` ServeMux (Go 1.22 patterns).
- Dockerfile (multi-stage, non-root, healthcheck).
### Что изменено
- `X-User-Id` больше не даёт доступ; бизнес-эндпоинты принимают только `Authorization: Bearer`. `X-User-Id` игнорируется (проверяется smoke-тестом: подстановка чужого id не меняет владельца сессии).
- `POST /auth/sessions` принимает только Basic; выдача `201 Session`, `DELETE /auth/sessions/current` → 204.
- `POST /users` требует `password` (12–128 code points).
- Всё состояние — в PostgreSQL; добавлены миграции `0001_init.sql`, `0002_sessions.sql`, `0003_messages_alt_index.sql`.
- Добавлен Redis как кэш сессий.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| ------------------------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| Offline-структура и локальные refs | `make check` | PASS | [png](evidence/1_Tests_Passing.png) |
| Полная OpenAPI 3.1 и JSON Schema | `make validate PYTHON=.venv/bin/python` | PASS | [png](evidence/1_Tests_Passing.png) |
| Публичный smoke, API lab1 с новой аутентификацией | `make test` | PASS | [png](evidence/1_Tests_Passing.png) |
| Persistence: перезапуск API+БД+Redis, токен жив | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS | [png](evidence/1_Tests_Passing.png) |
| Нагрузочный тест | `make load` | "failed_requests": 0, "error_ratio": 0.0, "successful_latency_ms": { "p50": 16.403, "p95": 27.836, "p99": 39.511 } | [png](evidence/1.2_Load_Passing.png) |
| Реальный перезапуск хранилищ (не no-op) | `docker compose stop postgres redis` → `start` → md5 users/messages до и после | md5 совпадают `volume inspect` показывает те же `CreatedAt` у pgdata/redisdata | [png](evidence/5_Volumes_Remain.png) |
| Контейнеры healthy | `docker compose ps` | api / postgres / redis — Up (healthy) | [png](evidence/2_Healthcheck.png) |
| Миграции идемпотентны | `docker compose logs migrate` | `NOTICE: relation ... already exists, skipping` для 0001/0002/0003, `migrations done` | [png](evidence/4_Migrations_Repeat.png) |
| Схема БД | `\d+ users chats chat_members messages sessions` | соответствует | [txt](evidence/lab2_db_schema.txt) |
| Стенд, volumes и секреты | `docker compose --env-file .env config --quiet`, `git check-ignore .env` | API, БД, Redis и frontend healthy; именованные тома; `.env` исключён из Git | [репозиторий](https://gitea.privcloud.tech/MiniLynx/mtusi2026lab2-fork) |
| TTL expiry (короткий SESSION_TTL_SECONDS) | `make my_tests` → `lab2_expiry.py --ttl 2` | `original SESSION_TTL_SECONDS=3600` → `SESSION_TTL_SECONDS=2` → токен 401 → `restoring SESSION_TTL_SECONDS=3600` | [png](evidence/3_My_Tests_Passing.png) |
| Гонка username | `lab2_extra.py` | `username race yields exactly one 201 and one 409` | [png](evidence/3_My_Tests_Passing.png) |
| Rollback CreateChat | `lab2_extra.py` | `create chat is atomic; unknown member aborts the whole operation` | [png](evidence/3_My_Tests_Passing.png) |
| Logout удаляет из источника истины | `lab2_extra.py` | `logout revokes session in source of truth` (401 → 401) | [png](evidence/3_My_Tests_Passing.png) |
| Redis down → API работает через БД | `lab2_extra.py` | `API works through DB when Redis is down` (`/health/ready` 200) | [png](evidence/3_My_Tests_Passing.png) |
| PostgreSQL down → 503 | `lab2_extra.py` | `/health/ready returns 503 when PostgreSQL is down` | [png](evidence/3_My_Tests_Passing.png) |
| Redis реально используется для сессий | `docker compose exec redis redis-cli KEYS 'session:*'` до и после `make test` | до: `(empty array)`; после: 2 ключа `session:uU8vOzLpbuPdAv6eughP4WkM6EePWjK9R6hAJ_1vO4`, `session:dVnW7V0E3VEPrnq_6_jg5nFIWO0RY2PIdZkIY7s-9tCj-Y` | [png](evidence/6_Redis_Used.png) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Трек 2. План запроса и восстановление
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Засев ≥100 000 сообщений | `psql < scripts/seed_messages.sql` | `seeded 150000 messages across 200 chats`; `count(*)=150000` | [png](evidence/7.1_Track2_Seeding.png) |
| Неравномерное распределение по чатам | `SELECT chat_id, count(*) ... GROUP BY chat_id ORDER BY n DESC LIMIT 10` | топ-5 чатов: 24286, 24200, 24187, 24074, 24029; далее единицы (181, 180, 175, 172, 171) — 80/20-профиль | [png](evidence/7.1_Track2_Seeding.png) |
| Размер таблицы и индексов | `pg_relation_size` / `pg_indexes_size` / `pg_total_relation_size` | table 30 MB, indexes 73 MB, total 104 MB | [png](evidence/7.1_Track2_Seeding.png) |
| VACUUM ANALYZE | `VACUUM (ANALYZE, VERBOSE) messages;` | 3879 pages, 150000 live, 0 dead; 150000 estimated rows | [png](evidence/7.2_Track2_Vacuum_Analyze.png) |
| EXPLAIN A (только узкий индекс) | DROP covering → VACUUM → `explain_A.sql` | `Index Scan using idx_messages_chat_created_id`, `Buffers: shared hit=18`, `Execution Time: 0.484 ms` | [png](evidence/7.3_Track2_Check_IndexA_Solo.png), [txt](evidence/explain_A.txt) |
| EXPLAIN B (узкий + покрывающий) | CREATE covering → VACUUM → `explain_B.sql` | `Index Only Scan using idx_messages_chat_covering`, `Heap Fetches: 0`, `Buffers: shared hit=6 read=5`, `Execution Time: 0.494 ms` | [png](evidence/7.4_Track2_Check_with_IndexB.png), [txt](evidence/explain_B.txt) |
| Размер индексов | `SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) FROM pg_indexes WHERE tablename='messages'` | covering 34 MB, created_id 18 MB, pkey 7480 kB | [png](evidence/7.5_Track2_Index_Size.png) |
| Стоимость записи: только A | DROP covering → `bench_insert.sql` (10 000 INSERT, `\timing on`) | `INSERT 0 10000`, `Time: 901.418 ms` | [png](evidence/7.6_Track2_Bench_Insert.png), [txt](evidence/insert_A.txt) |
| Стоимость записи: A+B | CREATE covering → `bench_insert.sql` | `INSERT 0 10000`, `Time: 1010.371 ms` | [png](evidence/7.6_Track2_Bench_Insert.png), [txt](evidence/insert_AB.txt) |
| Статистика индексов | `pg_stat_reset(); 20×SELECT...; pg_stat_user_indexes` | `idx_messages_chat_covering: idx_scan=20, idx_tup_read=1020, idx_tup_fetch=0`; `idx_messages_chat_created_id: idx_scan=0` — planner выбрал покрывающий | [png](evidence/7.7_Track2_Idx_Stat.png) |
| Backup | `time sh scripts/backup.sh evidence` | `real 0m1.829s`, файл `evidence/lab2_track2_backup_20261009T125319Z.dump` | [png](evidence/7.9_Track2_Backup.png) |
| Restore в новую БД | `time docker compose exec -T postgres pg_restore ... < "$DUMP"` | `real 0m4.093s`; `\dt` в `messenger_restore` показывает users/chats/chat_members/messages/sessions | [png](evidence/7.9_Track2_Backup.png) |
| Сверка count | `SELECT count(*) FROM messenger_restore.messages` | `160000` (150000 seed + 10000 bench) | [png](evidence/7.9_Track2_Backup.png) |
| Сверка md5 + контрольные UUID | `md5(string_agg(... ORDER BY id))` в src и dst | `src=b67e892fa51734cdd2fe263931a4c7d4` == `dst=b67e892fa51734cdd2fe263931a4c7d4`, `MATCH`; 5 самых старых сообщений совпадают побайтово по id/chat_id/sender_id/created_at | [png](evidence/7.a_Track2_Verify.png) |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
#### Трек 2. План запроса и восстановление
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
### Гипотеза
1. Для keyset-пагинации `ORDER BY (created_at, id) LIMIT 51` узкий индекс `(chat_id, created_at, id)` даёт `Index Scan` + heap fetches. Покрывающий `(chat_id, created_at, id) INCLUDE (sender_id, text)` позволяет `Index Only Scan` без обращений к heap. Ожидание — меньше `Buffers` и стабильнее latency на больших историях.
2. Плата — рост размера индекса и замедление INSERT на горячий чат (вторая структура, шире запись).
3. Логический backup/restore в отдельную БД даёт побайтовое совпадение count и контрольных UUID; время восстановления линейно от размера дампа.
### Методика
- `scripts/seed_messages.sql` — 150 000 сообщений, 50 пользователей, 200 чатов, 80% сообщений в 5 «горячих» чатах (см. [png](evidence/7.1_Track2_Seeding.png)). Пароли seed-пользователей — фиктивный bcrypt-хеш, для FK и планов этого достаточно.
- `VACUUM (ANALYZE, VERBOSE) messages;` перед EXPLAIN ([png](evidence/7.2_Track2_Vacuum_Analyze.png)).
- `scripts/explain_A.sql` — с только узким индексом; `scripts/explain_B.sql` — с обоими; оба `EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)`.
- `scripts/bench_insert.sql` — 10 000 INSERT в один чат, `\timing on`, без индекса B и с ним.
- `pg_stat_reset()` + 20 запросов + `pg_stat_user_indexes` — чтобы planner выбрал индекс по реальной статистике.
- `scripts/backup.sh` (`pg_dump -Fc`), `scripts/restore.sh` (новая БД `messenger_restore` на том же инстансе), сверка — `md5(string_agg(... ORDER BY id))` в обеих БД и контрольные 5 UUID по `created_at, id`.
Hardware/лимиты:
- Хост: Windows 11, WSL2, AMD Ryzen 5 3500U, 8 ядер, 8 GB RAM.
- Контейнеры: без явных CPU/RAM-лимитов; один Docker-host.
- Версии: Docker Engine 29.1.3, PostgreSQL 16.3, Redis 7.2.5, Go 1.22, alpine 3.20.
#### Результаты
**EXPLAIN (150 000 сообщений, топ-чат 24 286 сообщений):**
| План | Узел | Buffers | Heap Fetches | Execution Time |
| ----------------------- | -------------------------------------------------- | ------------------- | ------------ | -------------- |
| A (только узкий) | `Index Scan using idx_messages_chat_created_id` | shared hit=18 | — | 0.484 ms |
| B (узкий + покрывающий) | `Index Only Scan using idx_messages_chat_covering` | shared hit=6 read=5 | 0 | 0.494 ms |
Покрывающий индекс убирает heap fetches и снижает `Buffers` (18 → 11). Execution Time на 51 строке в пределах шума — это ожидаемо, выигрыш проявляется на больших страницах.
**Размер индексов:**
| Индекс | Размер |
| ------------------------------ | ------- |
| `idx_messages_chat_covering` | 34 MB |
| `idx_messages_chat_created_id` | 18 MB |
| `messages_pkey` | 7480 kB |
**Стоимость записи (10 000 INSERT в один чат):**
| Индексы | Время |
| -------- | ----------- |
| Только A | 901.418 ms |
| A + B | 1010.371 ms |
Прирост ~12% на запись — плата за покрывающий индекс. Для горячего чата это осознанный компромисс.
**Статистика использования индексов (после `pg_stat_reset()` и 20 запросов):**
| Индекс | idx_scan | idx_tup_read | idx_tup_fetch |
| ------------------------------ | -------- | ------------ | ------------- |
| `idx_messages_chat_covering` | 20 | 1020 | 0 |
| `idx_messages_chat_created_id` | 0 | 0 | 0 |
| `messages_pkey` | 0 | 0 | 0 |
Planner предпочёл покрывающий индекс. `idx_tup_fetch=0` подтверждает Index Only Scan.
**Backup / restore:**
| Сценарий | Время |
| ---------------------------------- | ------------------------------------------ |
| `pg_dump -Fc` (160 000 сообщений) | 1.829 s |
| `pg_restore` в `messenger_restore` | 4.093 s |
| Восстановленный count | 160000 |
| md5 src == dst | `b67e892fa51734cdd2fe263931a4c7d4` (MATCH) |
| 5 контрольных UUID | совпадают побайтово |
#### Выводы по треку
- Гипотеза 1 подтверждена: покрывающий индекс переводит чтение в `Index Only Scan`, убирая heap fetches. На 150 000 сообщениях planner действительно выбирает его, `idx_tup_fetch=0`.
- Гипотеза 2 подтверждена: два индекса дороже на записи (+12% на 10 000 INSERT). Для горячего чата (24 286 сообщений) это оправданный компромисс; в реальной системе имело бы смысл оставить только один или разнести чтение/запись.
- Гипотеза 3 подтверждена: логический restore даёт побайтовое совпадение count и контрольных UUID. **Граница:** восстановление выполнено в новую БД на том же PostgreSQL-инстансе, а не на отдельный host. Это учебный компромисс; реальный DR требует отдельного инстанса, проверки WAL/архива и измерения RPO/RTO, чего здесь нет.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| ------------------------------------------------ | ------------------------------- | --------------------------------------------------------------------- | ------------------------------------- |
| SIGTERM | Корректное завершение ≤10 с | `shutting down... → stopped`, exit 0 | ≤1 с; данные не теряются (PostgreSQL) |
| `docker compose restart postgres redis` без `-v` | Данные и токен сессии живы | `make test-persistence` PASS; md5 users/messages до и после совпадают | ~5–10 с |
| Redis недоступен | API работает через PostgreSQL | 200 на `/health/ready` и бизнес-запросах | без потерь |
| PostgreSQL недоступен | `/health/ready` → 503 | 503 | до восстановления контейнера |
| Истечение SESSION_TTL_SECONDS=2 | Токен → 401 | PASS, `.env` восстановлен до 3600 | — |
| Logout | Токен отозван, повтор → 401 | 204 → 401 → 401 | — |
| Неверный пароль | 401 с `WWW-Authenticate: Basic` | совпадает | — |
| Гонка одинакового username | Ровно один 201, остальные 409 | PASS | — |
| CreateChat с неизвестным участником | 400, частичного чата нет | PASS | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Один Docker-host.** Падение хоста или PostgreSQL-контейнера не покрывается.
- **Redis — кэш, не источник истины.** При `flushall`/рестарте сессии читаются из PostgreSQL. `appendonly yes` + `save 60 1` включены для случая, если Redis станет единственным хранилищем сессий.
- **Кэш консистентен, но не согласован.** После `Revoke` мы явно удаляем ключ; при падении API между `DELETE` в БД и `DEL` в Redis возможно окно «висячего» кэша с истёкшим TTL. TTL ограничивает окно.
- **Seed-пользователи не логинятся** (фиктивный `password_hash`). Для трека 2 это неважно; в защите не пытайтесь залогиниться под `seed_u_*`.
- **`scripts/verify_restore.sql` не использовался** в финальном прогоне: он опирается на `dblink`, а расширение не установлено. Сверка выполнена `md5(string_agg(... ORDER BY id))` в обеих БД + сравнение 5 контрольных UUID. Скрипт `verify_restore.sql` следует либо дополнить `CREATE EXTENSION IF NOT EXISTS dblink;`, либо заменить на md5-сверку.
- **`scripts/restore.sh` восстанавливает в БД на том же инстансе.** Не считается DR. Реальный DR — отдельный инстанс, WAL/архив, RPO/RTO.
- **`down -v` — destructive-команда** для намеренного удаления учебных данных; в persistence-сценарии не используется.
- **Отчёт не содержит** токенов, `.env`, `secrets/*.txt`, signed URL, приватных ключей, реальных сообщений. Все пользователи синтетические.
+80
View File
@@ -0,0 +1,80 @@
package main
import (
"context"
"errors"
"fmt"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"mtusi-messenger/src/api"
"mtusi-messenger/src/config"
"mtusi-messenger/src/domain"
)
func main() {
cfg := config.Load()
if cfg.DatabaseURL == "" {
log.Fatal("DATABASE_URL is required (env DATABASE_URL or DATABASE_URL_FILE)")
}
rootCtx, cancelRoot := context.WithCancel(context.Background())
defer cancelRoot()
store, err := domain.NewStore(rootCtx, cfg.DatabaseURL)
if err != nil {
log.Fatalf("postgres: %v", err)
}
defer store.Close()
// Кэш сессий в Redis/Valkey. Если CACHE_URL не задан — работаем без кэша.
var cache *domain.SessionCache
if cfg.CacheURL != "" {
cache, err = domain.NewSessionCache(rootCtx, cfg.CacheURL)
if err != nil {
if cfg.RedisRequired {
log.Fatalf("redis required but unavailable: %v", err)
}
log.Printf("redis unavailable, continuing without session cache: %v", err)
cache = nil
} else {
defer cache.Close()
}
} else if cfg.RedisRequired {
log.Fatal("SESSION_STORE=redis but CACHE_URL is not configured")
}
sessions := domain.NewSessionStore(store, cache, cfg.SessionTTL)
handler := &api.Handler{Store: store, Sessions: sessions}
router := api.NewRouter(handler)
srv := &http.Server{
Addr: fmt.Sprintf("%s:%d", cfg.Host, cfg.Port),
Handler: router,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
go func() {
log.Printf("messenger listening on %s (env=%s, session_ttl=%s)", srv.Addr, cfg.Env, cfg.SessionTTL)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("server error: %v", err)
}
}()
<-stop
log.Println("shutting down...")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_ = srv.Shutdown(ctx)
log.Println("stopped")
}
+84
View File
@@ -0,0 +1,84 @@
services:
postgres:
image: postgres:16.3-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 20
networks: [backend]
redis:
image: redis:7.2.5-alpine
command: ["redis-server", "--appendonly", "yes", "--save", "60", "1"]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
networks: [backend]
api:
build:
context: .
dockerfile: Dockerfile
env_file:
- .env
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
APP_ENV: "lab"
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
ports:
- "8080:8080"
networks: [backend]
migrate:
build:
context: .
dockerfile: Dockerfile
entrypoint: ["/app/migrate.sh"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
networks: [backend]
restart: "no"
volumes:
pgdata:
redisdata:
networks:
backend:
driver: bridge
secrets:
postgres_password:
file: ./secrets/postgres_password.txt
database_url:
file: ./secrets/database_url.txt
cache_url:
file: ./secrets/cache_url.txt
Binary file not shown.

After

Width:  |  Height:  |  Size: 36 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 56 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 57 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 113 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 104 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 101 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 96 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 97 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 106 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 108 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 35 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 78 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 75 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 97 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 134 KiB

+22
View File
@@ -0,0 +1,22 @@
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5.42..193.35 rows=51 width=178) (actual time=0.231..0.269 rows=51 loops=1)
Buffers: shared hit=18
InitPlan 1 (returns $0)
-> Limit (cost=5.00..5.00 rows=1 width=24) (actual time=0.144..0.145 rows=1 loops=1)
Buffers: shared hit=5
-> Sort (cost=5.00..5.50 rows=200 width=24) (actual time=0.144..0.144 rows=1 loops=1)
Sort Key: chats.created_at
Sort Method: top-N heapsort Memory: 25kB
Buffers: shared hit=5
-> Seq Scan on chats (cost=0.00..4.00 rows=200 width=24) (actual time=0.015..0.046 rows=200 loops=1)
Buffers: shared hit=2
-> Index Scan using idx_messages_chat_created_id on messages (cost=0.42..2763.99 rows=750 width=178) (actual time=0.230..0.262 rows=51 loops=1)
Index Cond: ((chat_id = $0) AND (ROW(created_at, id) > ROW('2000-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Buffers: shared hit=18
Planning:
Buffers: shared hit=130
Planning Time: 1.978 ms
Execution Time: 0.484 ms
(18 rows)
+23
View File
@@ -0,0 +1,23 @@
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5.42..12.15 rows=51 width=178) (actual time=0.258..0.290 rows=51 loops=1)
Buffers: shared hit=6 read=5
InitPlan 1 (returns $0)
-> Limit (cost=5.00..5.00 rows=1 width=24) (actual time=0.128..0.129 rows=1 loops=1)
Buffers: shared hit=5
-> Sort (cost=5.00..5.50 rows=200 width=24) (actual time=0.128..0.129 rows=1 loops=1)
Sort Key: chats.created_at
Sort Method: top-N heapsort Memory: 25kB
Buffers: shared hit=5
-> Seq Scan on chats (cost=0.00..4.00 rows=200 width=24) (actual time=0.019..0.044 rows=200 loops=1)
Buffers: shared hit=2
-> Index Only Scan using idx_messages_chat_covering on messages (cost=0.42..99.42 rows=750 width=178) (actual time=0.256..0.284 rows=51 loops=1)
Index Cond: ((chat_id = $0) AND (ROW(created_at, id) > ROW('2000-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Heap Fetches: 0
Buffers: shared hit=6 read=5
Planning:
Buffers: shared hit=152
Planning Time: 2.105 ms
Execution Time: 0.494 ms
(19 rows)
+3
View File
@@ -0,0 +1,3 @@
Timing is on.
INSERT 0 10000
Time: 901.418 ms
+3
View File
@@ -0,0 +1,3 @@
Timing is on.
INSERT 0 10000
Time: 1010.371 ms (00:01.010)
+77
View File
@@ -0,0 +1,77 @@
Table "public.users"
Column | Type | Collation | Nullable | Default
---------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
username | text | | not null |
display_name | text | | not null |
password_hash | text | | not null |
created_at | timestamp with time zone | | not null | now()
Indexes:
"users_pkey" PRIMARY KEY, btree (id)
"users_username_key" UNIQUE CONSTRAINT, btree (username)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
Table "public.chats"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
title | text | | not null |
created_at | timestamp with time zone | | not null | now()
Indexes:
"chats_pkey" PRIMARY KEY, btree (id)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
TABLE "messages" CONSTRAINT "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
Table "public.chat_members"
Column | Type | Collation | Nullable | Default
---------+------+-----------+----------+---------
chat_id | uuid | | not null |
user_id | uuid | | not null |
Indexes:
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
Foreign-key constraints:
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
Table "public.messages"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
chat_id | uuid | | not null |
sender_id | uuid | | not null |
text | text | | not null |
created_at | timestamp with time zone | | not null | now()
Indexes:
"messages_pkey" PRIMARY KEY, btree (id)
"idx_messages_chat_covering" btree (chat_id, created_at, id) INCLUDE (sender_id, text)
"idx_messages_chat_created_id" btree (chat_id, created_at, id)
Foreign-key constraints:
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
Table "public.sessions"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
token | text | | not null |
user_id | uuid | | not null |
expires_at | timestamp with time zone | | not null |
created_at | timestamp with time zone | | not null | now()
Indexes:
"sessions_pkey" PRIMARY KEY, btree (token)
"idx_sessions_expires" btree (expires_at)
"idx_sessions_user" btree (user_id)
Foreign-key constraints:
"sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
Index "public.idx_messages_chat_created_id"
Column | Type | Key? | Definition | Storage | Stats target
------------+--------------------------+------+------------+---------+--------------
chat_id | uuid | yes | chat_id | plain |
created_at | timestamp with time zone | yes | created_at | plain |
id | uuid | yes | id | plain |
btree, for table "public.messages"
Binary file not shown.
+21
View File
@@ -0,0 +1,21 @@
module mtusi-messenger
go 1.22
require (
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.5.5
github.com/redis/go-redis/v9 v9.5.1
golang.org/x/crypto v0.23.0
)
require (
github.com/cespare/xxhash/v2 v2.2.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
github.com/jackc/puddle/v2 v2.2.1 // indirect
golang.org/x/sync v0.1.0 // indirect
golang.org/x/sys v0.20.0 // indirect
golang.org/x/text v0.15.0 // indirect
)
+42
View File
@@ -0,0 +1,42 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw=
github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8=
github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+31
View File
@@ -0,0 +1,31 @@
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()
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE 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()
);
-- Индекс истории: ровно под ORDER BY (created_at, id) и keyset-курсор.
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id
ON messages (chat_id, created_at, id);
+9
View File
@@ -0,0 +1,9 @@
CREATE TABLE IF NOT EXISTS sessions (
token TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions (user_id);
CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions (expires_at);
+5
View File
@@ -0,0 +1,5 @@
-- Индекс B для «стоимости записи»:
-- покрывающий индекс, включающий text — растёт быстрее, помогает только
-- покрывающим запросам.
CREATE INDEX IF NOT EXISTS idx_messages_chat_covering
ON messages (chat_id, created_at, id) INCLUDE (sender_id, text);
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
# Логический backup БД messenger в файл на хосте.
# Формат custom (-Fc) позволяет pg_restore с параллелизмом.
OUT_DIR="${1:-evidence}"
mkdir -p "$OUT_DIR"
STAMP=$(date -u +%Y%m%dT%H%M%SZ)
FILE="$OUT_DIR/lab2_track2_backup_${STAMP}.dump"
docker compose --env-file .env exec -T postgres \
pg_dump -U messenger -d messenger -Fc \
> "$FILE"
echo "$FILE"
+10
View File
@@ -0,0 +1,10 @@
\timing on
-- 10 000 вставок в один чат.
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT
gen_random_uuid(),
(SELECT id FROM chats ORDER BY created_at LIMIT 1),
(SELECT id FROM users ORDER BY created_at LIMIT 1),
'bench ' || g,
now() - (g || ' milliseconds')::interval
FROM generate_series(1, 10000) g;
+8
View File
@@ -0,0 +1,8 @@
-- План чтения по «узкому» индексу (baseline). text достаётся через heap.
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = (SELECT id FROM chats ORDER BY created_at LIMIT 1)
AND (created_at, id) > ('2000-01-01T00:00:00Z', '00000000-0000-0000-0000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+9
View File
@@ -0,0 +1,9 @@
-- Тот же запрос, но planner имеет выбор: узкий vs покрывающий индекс.
-- После VACUUM ANALYZE PostgreSQL может выбрать Index Only Scan.
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = (SELECT id FROM chats ORDER BY created_at LIMIT 1)
AND (created_at, id) > ('2000-01-01T00:00:00Z', '00000000-0000-0000-0000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
set -eu
# Применяет миграции к БД, читая DATABASE_URL из файла секрета.
# Устойчиво к повторному запуску (CREATE ... IF NOT EXISTS).
URL_FILE="${DATABASE_URL_FILE:-/run/secrets/database_url}"
DATABASE_URL="$(cat "$URL_FILE")"
PSQL="psql $DATABASE_URL -v ON_ERROR_STOP=1 -q"
for f in migrations/*.sql; do
echo "applying $f"
$PSQL -f "$f"
done
echo "migrations done"
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
set -eu
# Перезапускает API и все хранилища (postgres, redis), сохраняя volumes.
# Никаких down -v / flush / reseed.
COMPOSE="docker compose --env-file .env"
$COMPOSE stop api
$COMPOSE restart postgres
$COMPOSE restart redis
# Ждём healthy у postgres и redis.
for i in $(seq 1 60); do
pg_ok=$($COMPOSE ps --format json postgres | grep -c '"Health":"healthy"' || true)
rd_ok=$($COMPOSE ps --format json redis | grep -c '"Health":"healthy"' || true)
if [ "$pg_ok" -ge 1 ] && [ "$rd_ok" -ge 1 ]; then
break
fi
sleep 1
done
$COMPOSE up -d api
# Готовность API проверит сам тест; здесь возвращаем 0.
exit 0
+16
View File
@@ -0,0 +1,16 @@
#!/bin/sh
set -eu
# Восстанавливает дамп в НОВУЮ БД messenger_restore на том же инстансе
# (учебный компромисс: физически это тот же PostgreSQL-контейнер,
# но логически — другое хранилище).
DUMP="$1"
[ -f "$DUMP" ] || { echo "no dump: $DUMP" >&2; exit 2; }
docker compose --env-file .env exec -T postgres \
psql -U messenger -d postgres -c "DROP DATABASE IF EXISTS messenger_restore;"
docker compose --env-file .env exec -T postgres \
psql -U messenger -d postgres -c "CREATE DATABASE messenger_restore OWNER messenger;"
docker compose --env-file .env exec -T postgres \
pg_restore -U messenger -d messenger_restore --no-owner --no-privileges < "$DUMP"
echo "restored into messenger_restore"
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
# Запускает собственные проверки lab2:
# 1) student_tests/lab2_expiry.py — короткий TTL, .env правится самим тестом;
# 2) student_tests/lab2_extra.py — все остальные сценарии.
# Первый шаг возвращает .env в исходное состояние до запуска второго.
set -eu
PYTHON="${PYTHON:-python3}"
BASE_URL="${BASE_URL:-http://localhost:8080}"
TMP_TTL="${TMP_TTL:-2}"
COMPOSE_ENV_FILE="${COMPOSE_ENV_FILE:-.env}"
COMPOSE_FILE="${COMPOSE_FILE:-compose.yaml}"
export COMPOSE_ENV_FILE COMPOSE_FILE
export PYTHON
echo "=== student_tests/lab2_expiry.py (SESSION_TTL_SECONDS=$TMP_TTL) ==="
"$PYTHON" student_tests/lab2_expiry.py \
--base-url "$BASE_URL" --ttl "$TMP_TTL"
echo "=== student_tests/lab2_extra.py ==="
"$PYTHON" student_tests/lab2_extra.py \
--base-url "$BASE_URL"
+63
View File
@@ -0,0 +1,63 @@
-- Синтетический датасет: 150 000 сообщений, неравномерное распределение по чатам.
-- Требует уже существующих пользователей и хотя бы одного чата;
-- создаёт дополнительные чаты и membership по необходимости.
DO $$
DECLARE
n_users CONSTANT int := 50;
n_chats CONSTANT int := 200;
n_messages CONSTANT int := 150000;
hot_chats CONSTANT int := 5;
i int;
uid uuid;
cid uuid;
chosen_chat uuid;
chosen_sender uuid;
r double precision;
uname text;
users_arr uuid[];
chats_arr uuid[];
BEGIN
-- Пользователи
FOR i IN 1..n_users LOOP
uid := gen_random_uuid();
uname := 'seed_u_' || i;
INSERT INTO users (id, username, display_name, password_hash)
VALUES (uid, uname, 'Seed ' || i, '$2a$10$invalidinvalidinvalidinvalidinvalidinvali')
ON CONFLICT (username) DO NOTHING;
users_arr := array_append(users_arr, uid);
END LOOP;
-- Чаты (равномерно по пользователям, все участники — выборка из users_arr)
FOR i IN 1..n_chats LOOP
cid := gen_random_uuid();
INSERT INTO chats (id, title) VALUES (cid, 'seed chat ' || i);
INSERT INTO chat_members (chat_id, user_id)
SELECT cid, unnest(users_arr[1 + (i % n_users) : 1 + ((i + 4) % n_users)])
ON CONFLICT DO NOTHING;
chats_arr := array_append(chats_arr, cid);
END LOOP;
-- Сообщения: 80% идут в 5 «горячих» чатов, 20% — равномерно по остальным.
FOR i IN 1..n_messages LOOP
r := random();
IF r < 0.80 THEN
chosen_chat := chats_arr[1 + (i % hot_chats)];
ELSE
chosen_chat := chats_arr[1 + (i % n_chats)];
END IF;
chosen_sender := users_arr[1 + (i % n_users)];
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (
gen_random_uuid(),
chosen_chat,
chosen_sender,
'seed message ' || i || ' ' || repeat('x', 1 + (i % 200)),
-- Разные timestamps: сдвигаем на i миллисекунд назад от now().
now() - (i || ' milliseconds')::interval
);
END LOOP;
RAISE NOTICE 'seeded % messages across % chats', n_messages, n_chats;
END $$;
+13
View File
@@ -0,0 +1,13 @@
-- Сверка: count + контрольные сообщения.
SELECT 'src' AS side, count(*) AS messages FROM messages
UNION ALL
SELECT 'restore', count(*) FROM dblink(
'dbname=messenger_restore user=messenger',
'SELECT count(*) FROM messages'
) AS t(n bigint);
-- Контрольные UUID: 5 самых старых сообщений.
SELECT id, chat_id, sender_id, text, created_at
FROM messages
ORDER BY created_at, id
LIMIT 5;
+79
View File
@@ -0,0 +1,79 @@
package api
import (
"context"
"encoding/base64"
"errors"
"net/http"
"strings"
"mtusi-messenger/src/domain"
)
// bearerAuth извлекает токен, проверяет сессию и кладёт пользователя в контекст.
// Basic на бизнес-эндпоинтах не принимается. X-User-Id игнорируется.
func (h *Handler) bearerAuth(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
header := r.Header.Get("Authorization")
if !strings.HasPrefix(header, "Bearer ") {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing bearer token")
return
}
token := strings.TrimSpace(strings.TrimPrefix(header, "Bearer "))
if token == "" {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing bearer token")
return
}
u, err := h.Sessions.Lookup(r.Context(), token)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrUnauthorized):
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid session")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable")
return
}
ctx := context.WithValue(r.Context(), userKey, *u)
ctx = context.WithValue(ctx, tokenKey, token)
next(w, r.WithContext(ctx))
}
}
func userFrom(r *http.Request) (domain.User, bool) {
u, ok := r.Context().Value(userKey).(domain.User)
return u, ok
}
func tokenFrom(r *http.Request) string {
if v, ok := r.Context().Value(tokenKey).(string); ok {
return v
}
return ""
}
// parseBasicCredentials разбирает Authorization: Basic base64(username:password).
func parseBasicCredentials(header string) (string, string, error) {
if !strings.HasPrefix(header, "Basic ") {
return "", "", errors.New("not basic")
}
raw := strings.TrimSpace(strings.TrimPrefix(header, "Basic "))
decoded, err := base64.StdEncoding.DecodeString(raw)
if err != nil {
return "", "", errors.New("invalid base64")
}
parts := strings.SplitN(string(decoded), ":", 2)
if len(parts) != 2 {
return "", "", errors.New("missing colon")
}
return parts[0], parts[1], nil
}
+28
View File
@@ -0,0 +1,28 @@
package api
import (
"encoding/json"
"net/http"
"mtusi-messenger/src/domain"
)
// writeError пишет ошибку в формате контракта.
func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(domain.ErrorBody{
Error: domain.ErrorDetail{
Code: code,
Message: message,
RequestID: requestIDFrom(r),
},
})
}
// writeJSON пишет успешный JSON-ответ.
func writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(v)
}
+298
View File
@@ -0,0 +1,298 @@
package api
import (
"encoding/json"
"errors"
"net/http"
"regexp"
"strconv"
"strings"
"mtusi-messenger/src/domain"
)
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type Handler struct {
Store *domain.Store
Sessions *domain.SessionStore
}
// --- Health ---
func (h *Handler) Live(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
// Ready проверяет БД (обязательная зависимость). Redis — кэш, его недоступность
// не должна ронять readiness: API может работать, обходя кэш.
func (h *Handler) Ready(w http.ResponseWriter, r *http.Request) {
if err := h.Store.Ping(r.Context()); err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
// --- Users ---
type createUserReq struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
var req createUserReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if !usernameRe.MatchString(req.Username) {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
return
}
if n := len([]rune(req.DisplayName)); n < 1 || n > 100 || strings.TrimSpace(req.DisplayName) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
return
}
// Пароль: 12–128 code points, не состоит только из пробелов.
if n := len([]rune(req.Password)); n < 12 || n > 128 || strings.TrimSpace(req.Password) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
return
}
u, err := h.Store.CreateUser(r.Context(), req.Username, req.DisplayName, req.Password)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrConflict):
writeError(w, r, http.StatusConflict, "conflict", "username taken")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, u)
}
func (h *Handler) CurrentUser(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
u, _ := userFrom(r)
writeJSON(w, http.StatusOK, u)
})(w, r)
}
// --- Auth ---
func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) {
username, password, err := parseBasicCredentials(r.Header.Get("Authorization"))
if err != nil {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials")
return
}
u, err := h.Store.VerifyPassword(r.Context(), username, password)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrUnauthorized):
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
writeError(w, r, http.StatusUnauthorized, "unauthorized", "invalid credentials")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
s, err := h.Sessions.Create(r.Context(), *u)
if err != nil {
if errors.Is(err, domain.ErrTimeout) {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store timeout")
return
}
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable")
return
}
writeJSON(w, http.StatusCreated, s)
}
func (h *Handler) RevokeSession(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
token := tokenFrom(r)
if err := h.Sessions.Revoke(r.Context(), token); err != nil {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "session store unavailable")
return
}
w.WriteHeader(http.StatusNoContent)
})(w, r)
}
// --- Chats ---
type createChatReq struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
var req createChatReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if strings.TrimSpace(req.Title) == "" || len([]rune(req.Title)) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
return
}
if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
return
}
c, err := h.Store.CreateChat(r.Context(), req.Title, req.MemberIDs, me.ID)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrInvalid):
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid members")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, c)
})(w, r)
}
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chats, err := h.Store.ListChats(r.Context(), me.ID)
if err != nil {
if errors.Is(err, domain.ErrTimeout) {
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
}
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, domain.ChatPage{Items: chats, NextCursor: nil})
})(w, r)
}
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
c, err := h.Store.GetChat(r.Context(), r.PathValue("chat_id"), me.ID)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrNotFound):
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, c)
})(w, r)
}
// --- Messages ---
type createMessageReq struct {
Text string `json:"text"`
}
func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chatID := r.PathValue("chat_id")
if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil {
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
}
var req createMessageReq
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON")
return
}
if len([]rune(req.Text)) > 4000 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "message too long")
return
}
if strings.TrimSpace(req.Text) == "" {
writeError(w, r, http.StatusBadRequest, "invalid_request", "empty message")
return
}
m, err := h.Store.AddMessage(r.Context(), chatID, me.ID, req.Text)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrNotFound):
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusCreated, m)
})(w, r)
}
func (h *Handler) ListMessages(w http.ResponseWriter, r *http.Request) {
h.bearerAuth(func(w http.ResponseWriter, r *http.Request) {
me, _ := userFrom(r)
chatID := r.PathValue("chat_id")
if _, err := h.Store.GetChat(r.Context(), chatID, me.ID); err != nil {
writeError(w, r, http.StatusNotFound, "not_found", "chat not found")
return
}
limit := 50
if v := r.URL.Query().Get("limit"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 1 || n > 100 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid limit")
return
}
limit = n
}
cursor := r.URL.Query().Get("cursor")
items, next, err := h.Store.ListMessages(r.Context(), chatID, limit, cursor)
switch {
case err == nil:
// ok
case errors.Is(err, domain.ErrInvalid):
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
return
case errors.Is(err, domain.ErrTimeout):
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "query timeout")
return
default:
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "database unavailable")
return
}
writeJSON(w, http.StatusOK, domain.MessagePage{Items: items, NextCursor: next})
})(w, r)
}
+35
View File
@@ -0,0 +1,35 @@
package api
import (
"context"
"net/http"
"github.com/google/uuid"
)
type ctxKey string
const (
requestIDKey ctxKey = "request_id"
userKey ctxKey = "user"
tokenKey ctxKey = "token"
)
func requestIDFrom(r *http.Request) string {
if v, ok := r.Context().Value(requestIDKey).(string); ok {
return v
}
return ""
}
func withRequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-Id")
if id == "" {
id = uuid.NewString()
}
w.Header().Set("X-Request-Id", id)
ctx := context.WithValue(r.Context(), requestIDKey, id)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
+19
View File
@@ -0,0 +1,19 @@
package api
import "net/http"
func NewRouter(h *Handler) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", h.Live)
mux.HandleFunc("GET /health/ready", h.Ready)
mux.HandleFunc("POST /api/v1/users", h.CreateUser)
mux.HandleFunc("GET /api/v1/users/me", h.CurrentUser)
mux.HandleFunc("POST /api/v1/auth/sessions", h.CreateSession)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", h.RevokeSession)
mux.HandleFunc("POST /api/v1/chats", h.CreateChat)
mux.HandleFunc("GET /api/v1/chats", h.ListChats)
mux.HandleFunc("GET /api/v1/chats/{chat_id}", h.GetChat)
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", h.CreateMessage)
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", h.ListMessages)
return withRequestID(mux)
}
+73
View File
@@ -0,0 +1,73 @@
package config
import (
"os"
"strconv"
"time"
)
type Config struct {
Host string
Port int
Env string
DatabaseURL string
CacheURL string
SessionTTL time.Duration
SessionStore string // "postgres" | "redis"
RedisRequired bool
}
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func readSecretFromFile(path string) string {
if path == "" {
return ""
}
b, err := os.ReadFile(path)
if err != nil {
return ""
}
return string(b)
}
func Load() Config {
port := 8080
if v := os.Getenv("APP_PORT"); v != "" {
if p, err := strconv.Atoi(v); err == nil {
port = p
}
}
ttl := 3600
if v := os.Getenv("SESSION_TTL_SECONDS"); v != "" {
if n, err := strconv.Atoi(v); err == nil && n > 0 {
ttl = n
}
}
// DATABASE_URL и CACHE_URL могут прийти либо напрямую, либо через *_FILE.
dbURL := os.Getenv("DATABASE_URL")
if dbURL == "" {
dbURL = readSecretFromFile(os.Getenv("DATABASE_URL_FILE"))
}
cacheURL := os.Getenv("CACHE_URL")
if cacheURL == "" {
cacheURL = readSecretFromFile(os.Getenv("CACHE_URL_FILE"))
}
store := getenv("SESSION_STORE", "postgres")
return Config{
Host: getenv("APP_HOST", "0.0.0.0"),
Port: port,
Env: getenv("APP_ENV", "lab"),
DatabaseURL: dbURL,
CacheURL: cacheURL,
SessionTTL: time.Duration(ttl) * time.Second,
SessionStore: store,
RedisRequired: store == "redis",
}
}
+91
View File
@@ -0,0 +1,91 @@
package domain
import (
"context"
"encoding/json"
"time"
"github.com/redis/go-redis/v9"
)
// SessionCache — необязательный кэш сессий поверх Redis.
// Источник истины — PostgreSQL. Кэш ускоряет проверку токена.
type SessionCache struct {
rdb *redis.Client
}
func NewSessionCache(ctx context.Context, url string) (*SessionCache, error) {
opt, err := redis.ParseURL(url)
if err != nil {
return nil, err
}
// Жёсткие короткие таймауты: Redis — кэш, а не критический путь.
opt.DialTimeout = 1 * time.Second
opt.ReadTimeout = 500 * time.Millisecond
opt.WriteTimeout = 500 * time.Millisecond
opt.MaxRetries = 0 // без автоматических ретраев: одна попытка — и уходим в БД
opt.PoolTimeout = 1 * time.Second
rdb := redis.NewClient(opt)
// Проверка связи при старте — короткая.
c, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
if err := rdb.Ping(c).Err(); err != nil {
_ = rdb.Close()
return nil, err
}
return &SessionCache{rdb: rdb}, nil
}
func (c *SessionCache) userKey(userID string) string { return "user:" + userID }
// opCtx возвращает контекст с коротким таймаутом для каждой операции.
// Не наследуем HTTP-контекст напрямую, чтобы не блокировать ответ клиенту.
func (c *SessionCache) opCtx() (context.Context, context.CancelFunc) {
return context.WithTimeout(context.Background(), 500*time.Millisecond)
}
// SetUser кладёт публичные данные пользователя в кэш с TTL до конца сессии.
func (c *SessionCache) SetUser(ctx context.Context, userID string, u User, expires time.Time) {
ttl := time.Until(expires)
if ttl <= 0 {
return
}
b, err := json.Marshal(u)
if err != nil {
return
}
opCtx, cancel := c.opCtx()
defer cancel()
_ = c.rdb.Set(opCtx, c.userKey(userID), b, ttl).Err()
}
func (c *SessionCache) GetUser(ctx context.Context, userID string) (User, bool) {
opCtx, cancel := c.opCtx()
defer cancel()
b, err := c.rdb.Get(opCtx, c.userKey(userID)).Bytes()
if err != nil {
return User{}, false
}
var u User
if err := json.Unmarshal(b, &u); err != nil {
return User{}, false
}
return u, true
}
// DelUser — на случай удаления пользователя (в lab2 не вызывается).
func (c *SessionCache) DelUser(ctx context.Context, userID string) error {
opCtx, cancel := c.opCtx()
defer cancel()
return c.rdb.Del(opCtx, c.userKey(userID)).Err()
}
func (c *SessionCache) Ping(ctx context.Context) error {
c2, cancel := context.WithTimeout(ctx, 1*time.Second)
defer cancel()
return c.rdb.Ping(c2).Err()
}
func (c *SessionCache) Close() error { return c.rdb.Close() }
+64
View File
@@ -0,0 +1,64 @@
package domain
import (
"errors"
"time"
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
}
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
User User `json:"user"`
}
type ErrorBody struct {
Error ErrorDetail `json:"error"`
}
type ErrorDetail struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
var (
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
ErrInvalid = errors.New("invalid request")
ErrUnauthorized = errors.New("unauthorized")
ErrTimeout = errors.New("timeout")
ErrUnavailable = errors.New("unavailable")
)
+445
View File
@@ -0,0 +1,445 @@
package domain
import (
"context"
"errors"
"fmt"
"strings"
"time"
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"golang.org/x/crypto/argon2"
)
type Store struct {
pool *pgxpool.Pool
}
func NewStore(ctx context.Context, dsn string) (*Store, error) {
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, classifyDBError(err)
}
cfg.MaxConns = 10
cfg.MinConns = 1
cfg.MaxConnLifetime = time.Hour
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.ConnConfig.ConnectTimeout = 5 * time.Second
cfg.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
_, err := conn.Exec(ctx, `
SET statement_timeout = '5s';
SET lock_timeout = '2s';
SET idle_in_transaction_session_timeout = '5s';
`)
return err
}
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, classifyDBError(err)
}
ctxPing, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(ctxPing); err != nil {
pool.Close()
return nil, classifyDBError(err)
}
return &Store{pool: pool}, nil
}
func (s *Store) Close() { s.pool.Close() }
func (s *Store) Ping(ctx context.Context) error {
c, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
return s.pool.Ping(c)
}
// Argon2id параметры — OWASP baseline: m=19456 KiB (19 MiB), t=2, p=1.
// Хеш кодируется в формате PHC: $argon2id$v=19$m=19456,t=2,p=1$<salt>$<hash>
const (
argonMemory uint32 = 19456
argonTime uint32 = 2
argonThreads uint8 = 1
argonKeyLen uint32 = 32
argonSaltLen = 16
)
func hashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", err
}
key := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
b64Salt := base64.RawStdEncoding.EncodeToString(salt)
b64Key := base64.RawStdEncoding.EncodeToString(key)
// PHC string; параметры можно будет менять в будущем, старые хеши останутся валидными.
return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
argonMemory, argonTime, argonThreads, b64Salt, b64Key), nil
}
func verifyPassword(password, encoded string) bool {
// Минимальный парсер PHC-строки.
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false
}
var mem, time uint32
var threads uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &time, &threads); err != nil {
return false
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false
}
wantKey, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false
}
gotKey := argon2.IDKey([]byte(password), salt, time, mem, threads, uint32(len(wantKey)))
return subtle.ConstantTimeCompare(gotKey, wantKey) == 1
}
// --- Users ---
func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*User, error) {
hash, err := hashPassword(password)
if err != nil {
return nil, classifyDBError(err)
}
id := uuid.NewString()
var u User
err = s.pool.QueryRow(ctx,
`INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1,$2,$3,$4)
RETURNING id, username, display_name, created_at`,
id, username, displayName, string(hash),
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "23505" {
return nil, ErrConflict
}
return nil, classifyDBError(err)
}
return &u, nil
}
func (s *Store) GetUserByID(ctx context.Context, id string) (*User, error) {
var u User
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at FROM users WHERE id=$1`, id,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, classifyDBError(err)
}
return &u, nil
}
// VerifyPassword возвращает пользователя, если пароль верный; иначе ErrUnauthorized.
func (s *Store) VerifyPassword(ctx context.Context, username, password string) (*User, error) {
var u User
var hash string
err := s.pool.QueryRow(ctx,
`SELECT id, username, display_name, created_at, password_hash FROM users WHERE username=$1`,
username,
).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
if errors.Is(err, pgx.ErrNoRows) {
// Тратим сопоставимое время на проверку фиктивного хеша,
// чтобы не различать "нет пользователя" и "неверный пароль" по таймингу.
_ = verifyPassword(password, "$argon2id$v=19$m=19456,t=2,p=1$AAAAAAAAAAAAAAAAAAAAAA$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
return nil, ErrUnauthorized
}
if err != nil {
return nil, classifyDBError(err)
}
if !verifyPassword(password, hash) {
return nil, ErrUnauthorized
}
return &u, nil
}
// --- Chats ---
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string, creatorID string) (*Chat, error) {
// Проверка входных данных.
seen := map[string]bool{}
for _, id := range memberIDs {
if seen[id] {
return nil, ErrInvalid
}
seen[id] = true
}
if !seen[creatorID] {
return nil, ErrInvalid
}
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted})
if err != nil {
return nil, classifyDBError(err)
}
defer tx.Rollback(ctx)
// Проверяем, что все участники существуют.
for id := range seen {
var exists bool
if err := tx.QueryRow(ctx, `SELECT true FROM users WHERE id=$1`, id).Scan(&exists); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrInvalid
}
return nil, classifyDBError(err)
}
}
chatID := uuid.NewString()
var c Chat
err = tx.QueryRow(ctx,
`INSERT INTO chats (id, title) VALUES ($1,$2) RETURNING id, title, created_at`,
chatID, title,
).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return nil, classifyDBError(err)
}
for id := range seen {
if _, err := tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id) VALUES ($1,$2)`,
c.ID, id,
); err != nil {
return nil, classifyDBError(err)
}
}
if err := tx.Commit(ctx); err != nil {
return nil, classifyDBError(err)
}
// Порядок member_ids — как в запросе.
c.MemberIDs = append([]string(nil), memberIDs...)
return &c, nil
}
func (s *Store) GetChat(ctx context.Context, chatID, userID string) (*Chat, error) {
var exists bool
err := s.pool.QueryRow(ctx,
`SELECT true FROM chat_members WHERE chat_id=$1 AND user_id=$2`,
chatID, userID,
).Scan(&exists)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, classifyDBError(err)
}
var c Chat
err = s.pool.QueryRow(ctx,
`SELECT id, title, created_at FROM chats WHERE id=$1`, chatID,
).Scan(&c.ID, &c.Title, &c.CreatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, classifyDBError(err)
}
rows, err := s.pool.Query(ctx,
`SELECT user_id FROM chat_members WHERE chat_id=$1 ORDER BY user_id`, chatID)
if err != nil {
return nil, classifyDBError(err)
}
defer rows.Close()
for rows.Next() {
var uid string
if err := rows.Scan(&uid); err != nil {
return nil, classifyDBError(err)
}
c.MemberIDs = append(c.MemberIDs, uid)
}
return &c, rows.Err()
}
func (s *Store) ListChats(ctx context.Context, userID string) ([]Chat, error) {
rows, err := s.pool.Query(ctx,
`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 = $1
ORDER BY c.created_at, c.id`, userID)
if err != nil {
return nil, classifyDBError(err)
}
defer rows.Close()
var chats []Chat
for rows.Next() {
var c Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, classifyDBError(err)
}
chats = append(chats, c)
}
if err := rows.Err(); err != nil {
return nil, classifyDBError(err)
}
// Догружаем участников (небольшие объёмы в учебном сценарии).
for i := range chats {
mrows, err := s.pool.Query(ctx,
`SELECT user_id FROM chat_members WHERE chat_id=$1 ORDER BY user_id`, chats[i].ID)
if err != nil {
return nil, classifyDBError(err)
}
for mrows.Next() {
var uid string
if err := mrows.Scan(&uid); err != nil {
mrows.Close()
return nil, classifyDBError(err)
}
chats[i].MemberIDs = append(chats[i].MemberIDs, uid)
}
mrows.Close()
}
if chats == nil {
chats = []Chat{}
}
return chats, nil
}
// --- Messages ---
func (s *Store) AddMessage(ctx context.Context, chatID, senderID, text string) (*Message, error) {
// Проверка членства + вставка в одной транзакции.
tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted})
if err != nil {
return nil, classifyDBError(err)
}
defer tx.Rollback(ctx)
var ok bool
if err := tx.QueryRow(ctx,
`SELECT true FROM chat_members WHERE chat_id=$1 AND user_id=$2`,
chatID, senderID,
).Scan(&ok); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, classifyDBError(err)
}
var m Message
err = tx.QueryRow(ctx,
`INSERT INTO messages (id, chat_id, sender_id, text)
VALUES ($1,$2,$3,$4)
RETURNING id, chat_id, sender_id, text, created_at`,
uuid.NewString(), chatID, senderID, text,
).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt)
if err != nil {
return nil, classifyDBError(err)
}
if err := tx.Commit(ctx); err != nil {
return nil, classifyDBError(err)
}
return &m, nil
}
// ListMessages — keyset-пагинация по (created_at, id).
// Курсор — это id последнего элемента предыдущей страницы; сам id уникален,
// поэтому используем его для поиска (created_at, id) в БД.
func (s *Store) ListMessages(ctx context.Context, chatID string, limit int, cursor string) ([]Message, *string, error) {
var rows pgx.Rows
var err error
if cursor == "" {
rows, err = s.pool.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id=$1
ORDER BY created_at, id
LIMIT $2`, chatID, limit+1)
} else {
// Определяем позицию курсора.
var cCreated time.Time
if err := s.pool.QueryRow(ctx,
`SELECT created_at FROM messages WHERE id=$1 AND chat_id=$2`,
cursor, chatID,
).Scan(&cCreated); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil, ErrInvalid
}
return nil, nil, classifyDBError(err)
}
rows, err = s.pool.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id=$1
AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4`, chatID, cCreated, cursor, limit+1)
}
if err != nil {
return nil, nil, classifyDBError(err)
}
defer rows.Close()
var items []Message
for rows.Next() {
var m Message
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return nil, nil, classifyDBError(err)
}
items = append(items, m)
}
if err := rows.Err(); err != nil {
return nil, nil, classifyDBError(err)
}
var next *string
if len(items) > limit {
items = items[:limit]
last := items[len(items)-1].ID
next = &last
}
if items == nil {
items = []Message{}
}
return items, next, nil
}
func classifyDBError(err error) error {
if err == nil {
return nil
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "57014": // query_canceled (statement_timeout)
return ErrTimeout
case "55P03": // lock_not_available (lock_timeout)
return ErrTimeout
case "40001": // serialization_failure
return ErrUnavailable
case "53300": // too_many_connections
return ErrUnavailable
}
}
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
return ErrTimeout
}
if errors.Is(err, pgx.ErrNoRows) {
return ErrNotFound
}
return err
}
+98
View File
@@ -0,0 +1,98 @@
package domain
import (
"context"
"crypto/rand"
"encoding/base64"
"errors"
"time"
"github.com/jackc/pgx/v5"
)
type SessionStore struct {
store *Store
cache *SessionCache
ttl time.Duration
}
func NewSessionStore(store *Store, cache *SessionCache, ttl time.Duration) *SessionStore {
return &SessionStore{store: store, cache: cache, ttl: ttl}
}
func newToken() (string, error) {
b := make([]byte, 32) // 256 бит
if _, err := rand.Read(b); err != nil {
return "", classifyDBError(err)
}
return base64.RawURLEncoding.EncodeToString(b), nil
}
// Create — пишем сессию в БД (источник истины) и кэшируем публичные данные User.
func (s *SessionStore) Create(ctx context.Context, user User) (*Session, error) {
token, err := newToken()
if err != nil {
return nil, classifyDBError(err)
}
expires := time.Now().UTC().Add(s.ttl)
if _, err := s.store.pool.Exec(ctx,
`INSERT INTO sessions (token, user_id, expires_at) VALUES ($1,$2,$3)`,
token, user.ID, expires); err != nil {
return nil, classifyDBError(err)
}
if s.cache != nil {
s.cache.SetUser(ctx, user.ID, user, expires)
}
return &Session{
Token: token,
TokenType: "Bearer",
ExpiresAt: expires,
User: user,
}, nil
}
// Lookup ВСЕГДА обращается к PostgreSQL за фактом существования сессии.
// Кэш используется только для публичных данных User.
func (s *SessionStore) Lookup(ctx context.Context, token string) (*User, error) {
var (
userID string
expiresAt time.Time
)
err := s.store.pool.QueryRow(ctx,
`SELECT user_id, expires_at FROM sessions WHERE token=$1`, token,
).Scan(&userID, &expiresAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrUnauthorized
}
if err != nil {
return nil, classifyDBError(err)
}
if time.Now().UTC().After(expiresAt) {
_, _ = s.store.pool.Exec(ctx, `DELETE FROM sessions WHERE token=$1`, token)
return nil, ErrUnauthorized
}
if s.cache != nil {
if u, ok := s.cache.GetUser(ctx, userID); ok {
return &u, nil
}
}
u, err := s.store.GetUserByID(ctx, userID)
if err != nil {
return nil, ErrUnauthorized
}
if s.cache != nil {
s.cache.SetUser(ctx, userID, *u, expiresAt)
}
return u, nil
}
func (s *SessionStore) Revoke(ctx context.Context, token string) error {
// Достаём user_id, чтобы потом сбросить кэш User (не обязательно, но полезно).
var userID string
_ = s.store.pool.QueryRow(ctx,
`DELETE FROM sessions WHERE token=$1 RETURNING user_id`, token,
).Scan(&userID)
return nil
}
+132
View File
@@ -0,0 +1,132 @@
#!/usr/bin/env python3
"""
Проверка истечения сессии при коротком SESSION_TTL_SECONDS.
Сам:
1. Запоминает текущее значение SESSION_TTL_SECONDS в .env.
2. Ставит временное (по умолчанию 2) и перезапускает контейнер api.
3. Ждёт /health/ready.
4. Регистрирует пользователя, создаёт сессию, убеждается, что токен живой,
ждёт TTL+2 с и убеждается, что тот же токен даёт 401.
5. Восстанавливает .env и перезапускает api (в finally).
Запуск:
python3 student_tests/lab2_expiry.py --base-url http://localhost:8080 --ttl 2
.env остаётся в исходном состоянии даже при ошибке теста.
"""
import base64
import os
import subprocess
import sys
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, Failure, LAB, arguments, check, run # noqa: E402
COMPOSE_ENV = os.environ.get('COMPOSE_ENV_FILE', '.env')
COMPOSE_FILE = os.environ.get('COMPOSE_FILE', 'compose.yaml')
def compose(*args, check_rc=True):
cmd = ['docker', 'compose', '--env-file', COMPOSE_ENV, '-f', COMPOSE_FILE, *args]
proc = subprocess.run(cmd, capture_output=True, text=True)
if check_rc and proc.returncode != 0:
raise Failure('compose %s failed: %s' % (' '.join(args), proc.stderr.strip()))
return proc
def read_env_ttl():
"""Возвращает (value, exists): значение SESSION_TTL_SECONDS из .env, если есть."""
try:
with open(COMPOSE_ENV, 'r', encoding='utf-8') as f:
for line in f:
if line.startswith('SESSION_TTL_SECONDS='):
return line.split('=', 1)[1].strip(), True
except FileNotFoundError:
raise Failure('no %s' % COMPOSE_ENV)
return '', False
def write_env_ttl(value, existed):
"""Перезаписывает SESSION_TTL_SECONDS, сохраняя остальные строки."""
with open(COMPOSE_ENV, 'r', encoding='utf-8') as f:
lines = f.readlines()
lines = [ln for ln in lines if not ln.startswith('SESSION_TTL_SECONDS=')]
if existed:
lines.append('SESSION_TTL_SECONDS=%s\n' % value)
with open(COMPOSE_ENV, 'w', encoding='utf-8') as f:
f.writelines(lines)
def restart_api():
compose('up', '-d', '--force-recreate', 'api')
def wait_ready(base_url, timeout=90):
# curl без внешних зависимостей: используем http.client через urllib.
import urllib.request
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
with urllib.request.urlopen(base_url + '/health/ready', timeout=2) as r:
if r.status == 200:
return
except Exception:
pass
time.sleep(0.5)
raise Failure('API did not become ready within %d s' % timeout)
def test_short_ttl_expiry(c, ttl_seconds):
username = 'ttl_' + str(int(time.time()))
password = 'T3st-' + username
body = {'username': username, 'display_name': 'TTL', 'password': password}
user = c.call('POST', '/api/v1/users', 201, body=body, schema='User')['json']
cred = base64.b64encode(('%s:%s' % (username, password)).encode()).decode()
session = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred},
schema='Session')['json']
actor = {'id': user['id'], 'user': user, 'token': session['token']}
c.call('GET', '/api/v1/users/me', 200, actor=actor, schema='User')
time.sleep(ttl_seconds + 2)
c.call('GET', '/api/v1/users/me', 401, actor=actor)
print('PASS: session expires after SESSION_TTL_SECONDS=%d' % ttl_seconds)
def main():
def configure(p):
p.add_argument('--ttl', type=int, default=2,
help='короткий SESSION_TTL_SECONDS на время теста')
args = arguments('Lab2: истечение сессии при коротком TTL', configure)
check(LAB == 2, 'this test targets lab2 only')
check(1 <= args.ttl <= 5, '--ttl must be 1..5 (короткий TTL только для этого теста)')
original, existed = read_env_ttl()
print('original SESSION_TTL_SECONDS=%s' % (original if existed else '<unset>'))
def restore():
print('restoring SESSION_TTL_SECONDS=%s' % (original if existed else '<unset>'))
write_env_ttl(original, existed)
restart_api()
try:
write_env_ttl(str(args.ttl), True)
print('starting API with SESSION_TTL_SECONDS=%d' % args.ttl)
restart_api()
wait_ready(args.base_url)
c = Client(args.base_url, args.ca_file)
test_short_ttl_expiry(c, args.ttl)
finally:
restore()
print('PASS: lab2 short-TTL expiry (own test)')
if __name__ == '__main__':
run(main)
+172
View File
@@ -0,0 +1,172 @@
#!/usr/bin/env python3
"""
Собственные проверки критериев уровня 4 lab2, не связанные с коротким TTL:
- гонка регистрации одного username (201 + 409);
- откат CreateChat при неизвестном участнике;
- logout удаляет сессию из источника истины;
- недоступность Redis/Valkey: API работает через БД;
- недоступность PostgreSQL: /health/ready → 503.
Истечение сессии при коротком SESSION_TTL_SECONDS — в lab2_expiry.py.
Запуск:
python3 student_tests/lab2_extra.py --base-url http://localhost:8080
"""
import base64
import os
import subprocess
import sys
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, Failure, LAB, arguments, check, run # noqa: E402
COMPOSE_ENV = os.environ.get('COMPOSE_ENV_FILE', '.env')
COMPOSE_FILE = os.environ.get('COMPOSE_FILE', 'compose.yaml')
def compose(*args, check_rc=True):
cmd = ['docker', 'compose', '--env-file', COMPOSE_ENV, '-f', COMPOSE_FILE, *args]
proc = subprocess.run(cmd, capture_output=True, text=True)
if check_rc and proc.returncode != 0:
raise Failure('compose %s failed: %s' % (' '.join(args), proc.stderr.strip()))
return proc
def test_redis_down_api_still_works(c):
"""Остановить Redis → API продолжает обслуживать через БД (источник истины)."""
alice, bob, eve, chat = c.bootstrap()
c.call('GET', '/api/v1/users/me', 200, actor=alice, schema='User')
compose('stop', '-t', '1', 'redis')
try:
c.call('GET', '/health/ready', 200, schema='Health')
c.call('GET', '/api/v1/users/me', 200, actor=alice, schema='User')
cred = base64.b64encode(
(alice['registration']['username'] + ':' + alice['registration']['password']).encode()
).decode()
c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')
c.message(bob, chat, 'redis down, but DB is up')
finally:
compose('start', 'redis')
for _ in range(30):
if compose('ps', '--format', 'json', 'redis', check_rc=False).stdout.find('"Health":"healthy"') >= 0:
break
time.sleep(0.5)
print('PASS: API works through DB when Redis is down')
def test_postgres_down_readiness_503(c):
"""Активный токен при недоступном PostgreSQL → 503, не 401."""
alice, _, _, _ = c.bootstrap()
# очищаем кэш, чтобы гарантированно идти в БД
compose('exec', '-T', 'redis', 'redis-cli', 'FLUSHALL')
compose('stop', '-t', '1', 'postgres')
try:
c.call('GET', '/api/v1/users/me', 503, actor=alice)
# анонимный доступ всё ещё 401
c.call('GET', '/api/v1/users/me', 401)
finally:
compose('start', 'postgres')
for _ in range(60):
if '"Health":"healthy"' in compose('ps', '--format', 'json', 'postgres', check_rc=False).stdout:
break
time.sleep(0.5)
print('PASS: PostgreSQL down returns 503 for valid token, not 401')
def test_username_race(c):
"""Два параллельных POST с одинаковым username: ровно один 201, другой 409."""
username = 'race_' + str(int(time.time() * 1000))[-8:]
body = {'username': username, 'display_name': 'Race',
'password': 'T3st-Race-password-123'}
def post():
try:
r = c.call('POST', '/api/v1/users', (201, 409), body=body)
return r['status']
except Failure:
return -1
with ThreadPoolExecutor(max_workers=2) as pool:
statuses = list(pool.map(lambda _: post(), range(2)))
check(sorted(statuses) == [201, 409],
'username race produced statuses %r, expected [201,409]' % statuses)
print('PASS: username race yields exactly one 201 and one 409')
def test_create_chat_rollback_unknown_member(c):
"""CreateChat с неизвестным UUID: 400, и в БД нет ни чата, ни membership."""
alice, _, _, _ = c.bootstrap()
unknown = '99999999-9999-4999-8999-999999999999'
body = {'title': 'rollback ' + str(int(time.time())),
'member_ids': [alice['id'], unknown]}
c.call('POST', '/api/v1/chats', 400, actor=alice, body=body)
listed = c.call('GET', '/api/v1/chats?limit=100', actor=alice, schema='ChatPage')['json']
check(all(ch['title'] != body['title'] for ch in listed['items']),
'rollback failed: partial chat persisted')
print('PASS: create chat is atomic; unknown member aborts the whole operation')
def test_logout_removes_from_source_of_truth(c):
"""Logout должен отзывать сессию так, чтобы она не воскресла из кэша/БД."""
alice, _, _, _ = c.bootstrap()
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
c.call('GET', '/api/v1/users/me', 401, actor=alice)
c.call('GET', '/api/v1/users/me', 401, actor=alice)
print('PASS: logout revokes session in source of truth')
def test_revoked_token_not_resurrected_by_redis(c):
"""Отозванный токен не оживает после рестарта Redis."""
alice, _, _, _ = c.bootstrap()
compose('stop', '-t', '1', 'redis')
try:
# logout при лежащем Redis
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
# токен уже не работает (Redis лежит, идём в БД)
c.call('GET', '/api/v1/users/me', 401, actor=alice)
finally:
compose('start', 'redis')
# ждём healthy
for _ in range(30):
out = compose('ps', '--format', 'json', 'redis', check_rc=False).stdout
if '"Health":"healthy"' in out:
break
time.sleep(0.5)
# ключевая проверка: после рестарта Redis тот же токен по-прежнему 401
c.call('GET', '/api/v1/users/me', 401, actor=alice)
print('PASS: revoked token is not resurrected by Redis restart')
def main():
def configure(p):
p.add_argument('--skip-docker', action='store_true',
help='пропустить сценарии с остановкой redis/postgres')
args = arguments('Lab2 собственные проверки уровня 4 (без короткого TTL)', configure)
check(LAB == 2, 'this test targets lab2 only')
c = Client(args.base_url, args.ca_file)
test_username_race(c)
test_create_chat_rollback_unknown_member(c)
test_logout_removes_from_source_of_truth(c)
if args.skip_docker:
print('SKIP: --skip-docker set; skipped redis/postgres down tests')
else:
test_redis_down_api_still_works(c)
test_postgres_down_readiness_503(c)
test_revoked_token_not_resurrected_by_redis(c)
print('PASS: lab2 level-4 criteria (own tests, no short TTL)')
if __name__ == '__main__':
run(main)