Author SHA1 Message Date
Rakshasa2 b758e18408 lab3- оценка 4 fixed 2026-10-23 15:14:57 +03:00
Rakshasa2 55788bb823 lab3- оценка 4 2026-10-21 14:00:40 +03:00
17 changed files with 1841 additions and 21 deletions
+27
View File
@@ -0,0 +1,27 @@
FROM golang:1.22-alpine AS builder
WORKDIR /build
COPY go.mod go.sum ./
RUN go mod download
COPY src/ ./src/
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/server ./src/cmd/server
FROM alpine:3.20
RUN addgroup -S app && adduser -S -G app app
WORKDIR /app
COPY --from=builder /out/server .
USER app
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=3 \
CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health/ready || exit 1
CMD ["./server"]
+94 -21
View File
@@ -1,37 +1,110 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа:** Тюрина Александра, БВТ2304
- **Целевая оценка:** 4.
- **Commit/PR:** `rakshasa/mtusi2026lab3-форк`, ветка `solution/tyuirna-bvt2304`.
- **Использованные источники, библиотеки и помощь ИИ:**
- Библиотеки: `github.com/go-chi/chi/v5` (роутер), `github.com/jackc/pgx/v5` + `pgxpool` (PostgreSQL), `github.com/redis/go-redis/v9` (кэш сессий), `golang.org/x/crypto/bcrypt` (хеширование паролей), `github.com/google/uuid` (идентификаторы). Стандартная библиотека Go 1.22 (`net/http`, `sync`, `crypto/rand`, `crypto/sha256`, `encoding/json`, `embed`).
- Инфраструктура: HAProxy 2.9‑alpine (load balancer + active health‑check), PostgreSQL 16‑alpine, Redis 7‑alpine (AOF persistence), Alpine 3.20 (runtime), golang:1.22‑alpine (builder).
- Помощь ИИ: консультации по архитектуре (выбор HAProxy вместо nginx‑OSS из‑за нативных active health‑check, схема идемпотентности через `pg_advisory_xact_lock`, сериализация миграций через `pg_advisory_lock`, паттерн keyset‑пагинации `LIMIT+1`), ревью кода на race conditions и отладка конфигурации HAProxy (HTTP/1.0 в `option httpchk`, `init-addr`, trailing newline). Весь код написан, собран и проверен автором прогонами, приведёнными ниже.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Версии runtime/образов.** Сборка и запуск полностью контейнеризованы, локальный Go не требуется. Образы закреплены по тегам: `golang:1.22-alpine` (builder), `alpine:3.20` (runtime), `haproxy:2.9-alpine`, `postgres:16-alpine`, `redis:7-alpine`.
**Prerequisites (локально).** Docker Engine + Compose v2 (`docker compose version`); `python3` ≥ 3.8 (запускатели тестов); `make`, `curl`, `uuidgen` (на macOS есть из коробки; на Linux — `uuid-runtime`). Локальный Go ≥ 1.22 нужен только для `go mod tidy` при изменении зависимостей — для сборки стенда не требуется.
**Локальные secrets / `.env` (оператор).** Секреты создаются отдельно и не коммитятся (`.env` исключён через `.gitignore`/`.dockerignore`); открытые конфигурации (`compose.yaml`, `infra/haproxy.cfg`, `migrations/*.sql`, `.env.example`, тестовые fixtures) хранятся в репозитории. Учебные креды БД — не продакшн‑секреты:
```bash
cp .env.example .env # PG_USER=lab3, PG_PASSWORD=lab3, PG_DB=lab3
```
`DATABASE_URL` и параметры `postgres`‑сервиса собираются из этих переменных через `${...}` в `compose.yaml`. `REDIS_URL` (`redis://redis:6379/0`) и `PORT` (`8080`) фиксированы внутри сети Compose — секретов нет. Убедиться, что порт `8080` на хосте свободен (LB маппит `127.0.0.1:8080:8080`).
**Build, миграции, запуск, ожидание готовности.** Миграции применяются автоматически при старте каждой реплики (`applyMigrations` в `NewPostgres`) и сериализованы advisory‑локом, поэтому отдельной команды миграций оператор не выполняет; повторный старт идемпотентен.
```bash
docker compose --env-file .env config --quiet # валидация compose до сборки
docker compose --env-file .env up -d --build # build + старт 5 сервисов
docker compose ps # lb, postgres, redis healthy; 2× api healthy
```
**Тесты.**
```bash
make test # публичный smoke (уровень 3)
make test-failover ACTION_SCRIPT=scripts/stop-one.sh # отказоустойчивость (уровень 4)
```
**Безопасная остановка (данные сохраняются).** `SIGTERM` → graceful shutdown реплик (< 10 с), volumes `postgres_data`/`redis_data` целы:
```bash
docker compose down
```
**Намеренное удаление учебных данных.** Стирание volumes (БД и Redis AOF):
```bash
docker compose down -v
```
**Действия оператора, которые необходимо выполнить вручную:** (1) создать `.env` из `.env.example`; (2) освободить хост‑порт 8080; (3) перед `make test-failover` убедиться, что обе реплики `Up (healthy)` и **не** останавливать их вручную (хук вызывает тест сам); (4) после каждого failover‑прогона восстанавливать реплику командой `docker compose up -d api` перед следующим прогоном.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Схема процессов/хранилищ.**
```
Клиент → HAProxy :8080 (roundrobin, active health-check /health/ready)
├─ api-1 (Go, X-Instance-Id = hostname контейнера)
└─ api-2 (Go, X-Instance-Id = hostname контейнера)
├─ PostgreSQL 16 (volume postgres_data) — источник истины
└─ Redis 7 AOF (volume redis_data) — кэш сессий (быстрый путь)
```
API‑реплики не публикуют порт наружу (только `expose`), весь трафик идёт через LB. `container_name` нигде не задан, масштабирование — через `deploy.replicas`.
**Источник истины.** PostgreSQL хранит пользователей, чаты, участников, сообщения, сессии и ключи идемпотентности. Redis — только кэш сессий: при входе сессия пишется в PostgreSQL (источник истины), затем дублируется в Redis; при проверке токена сначала Redis, при промахе/недоступности — fallback в PostgreSQL с проверкой `expires_at`. Поэтому полное падение Redis не теряет сессии и данные (деградация по латентности, не по корректности); при недоступности Redis на логине API честно отдаёт `503`, не создавая «висячую» сессию.
**Транзакционные границы.**
- `CreateUser` — одиночный `INSERT … RETURNING`; уникальность `username` обеспечивается констрейнтом → `ErrConflict` (409).
- `CreateChat` — одна транзакция: `INSERT chat` + N × `INSERT chat_members` + `COMMIT`; чат и участники атомарны.
- `SendMessageIdempotent` — одна транзакция с `pg_advisory_xact_lock(scope)`, где `scope = user|method|path|key`; внутри — `SELECT` существующего ключа, затем либо `replay` сохранённого тела, либо атомарные `INSERT message` + `INSERT idempotency_key`. Lock удерживается до `COMMIT`, поэтому параллельные запросы с одним ключом, пришедшие на **разные** реплики, сериализуются на стороне PostgreSQL — гонка «два разных id на один ключ» невозможна.
- Миграции — `pg_advisory_lock` на выделенном соединении сериализует применение между репликами; каждая миграция — отдельный `Exec`; версия фиксируется в `schema_migrations`; SQL идемпотентен (`IF NOT EXISTS`).
**Ограничения.** Единая PostgreSQL (не кластер) — SPOF для БД; Redis без репликации/кластера (persistence AOF `everysec` компенсирует рестарт, но не потерю диска одного хоста); `X-Instance-Id` = hostname контейнера (не устойчив к пересозданию, но достаточно для демонстрации разных процессов); нагрузка в `tests/load.py` closed‑loop (см. «Эксперименты»).
**Что перенесено из lab2 без существенных изменений.** Модель данных и SQL‑логика CRUD (`users`/`chats`/`chat_members`/`messages`/`sessions`), bcrypt‑хеширование паролей, генерация/хеш токенов (`crypto/rand` + SHA‑256), схема Basic→Bearer, Redis‑кэш сессий с таймаутами пула и `noeviction`, `Dockerfile` (multi‑stage, non‑root `app`, healthcheck), `.dockerignore`, `student-tests/`.
**Что изменено/добавлено в lab3.**
- `compose.yaml`: HAProxy LB + `deploy.replicas: 2` у api без `container_name`, `expose` вместо `ports` у api, CPU/RAM‑лимиты на всех сервисах, `depends_on … condition: service_healthy`.
- `infra/haproxy.cfg`: `server-template api 2 api:8080 check`, `resolvers docker`, `default-server inter 2s fall 3 rise 2 init-addr libc,none`, health‑check через `option httpchk GET /health/ready`.
- `main.go`: middleware `X-Instance-Id` (`instanceID` из `os.Hostname()`), `Idempotency-Key` обязателен в `SendMessage`; `DELETE /auth/sessions/current` перенесён в защищённую группу (middleware проверяет сессию → повторный logout даёт 401, а не 204).
- `postgres.go`: метод `SendMessageIdempotent` + `pg_advisory_xact_lock`; `pg_advisory_lock` для миграций; keyset‑пагинация `LIMIT+1` (фикс «вторая страница должна завершать историю» — раньше `next_cursor` ложно выставлялся, когда остаток ровно равен `limit`).
- `migrations/002_idempotency.sql`: таблица `idempotency_keys` (уникальность по `user_id, method, path, key`, хранение `request_hash` и `response_body` для replay/409) + индекс по `expires_at`.
- `scripts/stop-one.sh`: остановка **работающей** реплики по `X-Instance-Id`, наблюдаемому через тот же LB‑канал, что и тест (`--filter status=running`, проверка `≥2` реплик); `scripts/restart.sh`: рестарт без `-v` с ожиданием readiness.
**Соответствие `.env.example` реальной конфигурации.** `PG_USER`/`PG_PASSWORD`/`PG_DB` из `.env` подставляются и в `DATABASE_URL` api‑реплик, и в окружение `postgres`‑сервиса — значения согласованы. `SESSION_TTL_SECONDS` в `compose.yaml` зафиксирован как `"3600"` (учебное упрощение: в lab2 читался из env; здесь TTL сделан константным, чтобы окно жизни сессии было предсказуемо для тестов отказов; при необходимости выносится в `.env` без изменения кода — `main.go` уже умеет читать `SESSION_TTL_SECONDS`). `REDIS_URL`/`PORT` фиксированы внутри сети Compose.
## Доказательства критериев
> Каждое доказательство сохраняется в `evidence/` перенаправлением вывода (`tee`). Токены и креды в файлы доказательств не попадают (см. примечание к `tests/load.py`: raw summary без tokens).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Запуск одной командой | `docker compose --env-file .env up -d --build` | 5 сервисов в `running/healthy`, две реплики api | `evidence/up.txt` (`docker compose ps \| tee …`) |
| ≥2 реплики + LB + общая БД + общие сессии | `docker compose ps`; один Bearer‑токен работает на обеих репликах | `api-1`, `api-2` healthy; smoke ходит через LB без повторного входа | `evidence/ps.txt` + `evidence/smoke.txt` |
| Разные `X-Instance-Id` без повторного входа | `for i in 1 2 3 4 5 6; do curl -s -D- -o/dev/null http://localhost:8080/health/live \| grep -i x-instance-id; done` | чередование двух значений: `5c592b270d4b` / `16a1f833c461` | `evidence/instance_ids.txt` |
| Публичный smoke (уровень 3) | `make test 2>&1 \| tee evidence/smoke.txt` | `PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.` | `evidence/smoke.txt` |
| Идемпотентность POST + конкурентный повтор + переключение реплики | покрыто `make test` + параллельный сценарий ниже | replay возвращает тот же `id`; другое тело → 409 | `evidence/idempotency_parallel.txt` |
| Health/readiness + SIGTERM согласованы; LB исключает backend (период и max время) | `infra/haproxy.cfg` (`inter 2s fall 3 rise 2`); `docker stop -t 10`; логи `lb`/`api` | исключение мёртвой реплики ≤ 6 с (факт 2.33 с), возврат ≈ 4 с; в логах api `shutting down…` / `exited properly` | `evidence/lb_healthchecks.txt`, `evidence/api_graceful.txt` |
| `make test-failover`, реплика 1 | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh 2>&1 \| tee evidence/failover_replica1.txt` | `{"observed_instances_before":2,"successful_writes":116,"failed_attempts":1,"first_recovery_seconds":2.33}` → `PASS` | `evidence/failover_replica1.txt` |
| Operator evidence (реально остановленный процесс), реплика 1 | `docker compose ps -a api \| tee evidence/operator_evidence_replica1.txt` | одна реплика `Up (healthy)`, вторая `Exited (0)` | `evidence/operator_evidence_replica1.txt` ⚠ догнать |
| `make test-failover`, реплика 2 (после восстановления 1) | `docker compose up -d api && sleep 10; make test-failover …` | второй `PASS` на другой реплике | `evidence/failover_replica2.txt` ⚠ догнать |
| Замеры RPS / ошибки / восстановление | `tests/load.py` baseline + failover с ручным `stop-one.sh` | см. таблицу «Эксперименты» | `evidence/load_baseline.json`, `evidence/load_failover.json` |
| Параллельная идемпотентность одним ключом через разные реплики | два одновременных `POST` с одним `Idempotency-Key` через LB | `id A==B==C: True`; дублей 1; повтор с другим телом → `409` | `evidence/idempotency_parallel.txt` ⚠ догнать |
| CPU/RAM‑лимиты; API не публикует порт в обход LB; нет `container_name` | `docker compose config \| grep -E 'cpus\|memory\|ports\|expose'`; `grep -n container_name compose.yaml` | лимиты на всех сервисах; у api только `expose`; `container_name` отсутствует | `evidence/compose_config.txt` ⚠ догнать |
| Rolling update под нагрузкой | `tests/load.py` + `--scale api=1` → `--scale api=2` | RPS не падает в ноль надолго, `error_ratio` мал | `evidence/load_rollout.json` ⚠ догнать |
| Миграции однократны и совместимы с работающей версией | рестарт реплик; логи `api`; `psql` count | после рестарта: `Skipping migration 001_initial.sql (already applied)` и `Skipping migration 002_idempotency.sql (already applied)`; `count(*) FROM schema_migrations = 2` | `evidence/migrations_once.txt` (логи уже подтверждают идемпотентность; `psql` count — подтверждающая команда) |
| Restart с сохранением volumes и токена | `./scripts/restart.sh; make test` | `ready`; smoke `PASS` после рестарта (данные БД живы; сохранность сессии следует из PostgreSQL‑источника истины + Redis AOF) | `evidence/restart_smoke.txt` |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
**Какие отказы выдерживаются.** Падение/остановка любой одной api‑реплики (LB исключает за ≤ 6 с, фактически 2.33 с; сессии и данные не теряются). Рестарт всего стенда без `-v` (данные и сессии живы). Полная недоступность Redis на время проверки токена — деградируем в PostgreSQL‑fallback (работоспособно, медленнее); на время логина — честный `503` без «висячих» сессий. Параллельные повторы с одним ключом на разные реплики — сериализуются advisory‑локом, дублей нет.
**Какие отказы не выдерживаются (учебные упрощения).** Падение PostgreSQL — SPOF (нет кластера/реплики; при потере диска volume данные теряются). Падение Redis вместе с потерей AOF‑файла — сессии восстанавливаются только из PostgreSQL‑fallback (Redis как единственное хранилище сессий не используется именно поэтому). `X-Instance-Id` = hostname контейнера не устойчив к пересозданию (для демонстрации разных процессов достаточно; для прода — отдельный `INSTANCE_ID` из env, код уже поддерживает). Единый хост в экспериментах — сетевые и дисковые контеншены не разделены.
**Что не реализовано / гипотеза vs подтверждено.** Подтверждено прогонами: балансировка (два `X-Instance-Id`), `make test` PASS, `make test-failover` PASS (реплика 1) с восстановлением 2.33 с, замеры baseline/failover, идемпотентность миграций (логи `Skipping migration`), graceful shutdown (логи `exited properly`), restart с сохранением volumes. Пока гипотеза, требующая прогона перед сдачей: второй failover‑про
+97
View File
@@ -0,0 +1,97 @@
services:
lb:
image: haproxy:2.9-alpine
ports:
- "127.0.0.1:8080:8080"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api:
condition: service_healthy
healthcheck:
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
interval: 10s
timeout: 3s
retries: 3
deploy:
resources:
limits:
cpus: "0.25"
memory: 64M
restart: unless-stopped
api:
build: .
expose:
- "8080"
environment:
PORT: "8080"
DATABASE_URL: postgres://${PG_USER}:${PG_PASSWORD}@postgres:5432/${PG_DB}?sslmode=disable&timezone=UTC
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: "3600"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/health/ready"]
interval: 5s
timeout: 3s
start_period: 10s
retries: 3
deploy:
replicas: 2
resources:
limits:
cpus: "0.50"
memory: 128M
restart: unless-stopped
postgres:
image: postgres:16-alpine
environment:
POSTGRES_USER: ${PG_USER}
POSTGRES_PASSWORD: ${PG_PASSWORD}
POSTGRES_DB: ${PG_DB}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${PG_USER} -d ${PG_DB}"]
interval: 5s
timeout: 5s
retries: 5
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
restart: unless-stopped
redis:
image: redis:7-alpine
command: >
redis-server
--appendonly yes
--appendfsync everysec
--auto-aof-rewrite-percentage 100
--auto-aof-rewrite-min-size 64mb
--maxmemory 128mb
--maxmemory-policy noeviction
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 5
deploy:
resources:
limits:
cpus: "0.25"
memory: 192M
restart: unless-stopped
volumes:
postgres_data:
redis_data:
+21
View File
@@ -0,0 +1,21 @@
module mtusi2026lab3-fork
go 1.22
require (
github.com/go-chi/chi/v5 v5.0.12
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.21.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/text v0.14.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/go-chi/chi/v5 v5.0.12 h1:9euLV5sTrTNTRUU9POmDUvfxyj6LAABLUcEWO+JJb4s=
github.com/go-chi/chi/v5 v5.0.12/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
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.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
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/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.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=
+30
View File
@@ -0,0 +1,30 @@
global
log stdout format raw local0 info
maxconn 4096
defaults
mode http
timeout connect 5s
timeout client 30s
timeout server 30s
timeout check 5s
option httplog
option dontlognull
resolvers docker
nameserver dns1 127.0.0.11:53
hold valid 5s
hold nx 5s
hold refused 5s
hold timeout 5s
frontend fe_main
bind *:8080
default_backend be_api
backend be_api
balance roundrobin
option httpchk GET /health/ready
http-check expect status 200
default-server inter 2s fall 3 rise 2 init-addr libc,none resolvers docker
server-template api 2 api:8080 check
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
set -eu
docker compose restart
echo "waiting for readiness ..."
for i in $(seq 1 30); do
if curl -sf http://localhost:8080/health/ready >/dev/null 2>&1; then
echo "ready"; exit 0
fi
sleep 1
done
echo "not ready after 30s" >&2
exit 1
+31
View File
@@ -0,0 +1,31 @@
#!/bin/sh
set -eu
BASE="${BASE_URL:-http://localhost:8080}"
RUNNING=$(docker ps --filter "label=com.docker.compose.service=api" --filter "status=running" -q)
COUNT=$(printf '%s\n' "$RUNNING" | grep -c . || true)
if [ "$COUNT" -lt 2 ]; then
echo "need >=2 running api replicas, found $COUNT" >&2
exit 1
fi
TARGET=$(curl -s -D - -o /dev/null "$BASE/health/live" \
| tr -d '\r' \
| awk 'tolower($1)=="x-instance-id:"{print $2}')
if [ -z "$TARGET" ]; then
echo "could not observe X-Instance-Id via LB" >&2
exit 1
fi
if ! printf '%s\n' "$RUNNING" | grep -qi "^${TARGET}"; then
CID=$(docker inspect --format '{{.Id}} {{.Config.Hostname}}' $RUNNING \
| awk -v t="$TARGET" '$2==t{print substr($1,1,12)}' | head -n 1)
[ -n "$CID" ] || { echo "target $TARGET not a running api replica" >&2; exit 1; }
TARGET="$CID"
fi
echo "stopping LB-observed replica $TARGET ..." >&2
docker stop -t 10 "$TARGET" >/dev/null
echo "stopped $TARGET" >&2
+152
View File
@@ -0,0 +1,152 @@
package main
import (
"context"
"log"
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
"mtusi2026lab3-fork/src/internal/handler"
"mtusi2026lab3-fork/src/internal/session"
"mtusi2026lab3-fork/src/internal/store"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/google/uuid"
)
var instanceID = func() string {
if v := os.Getenv("INSTANCE_ID"); v != "" {
return v
}
if h, err := os.Hostname(); err == nil && h != "" {
return h
}
return "unknown"
}()
func RequestIDMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestID := uuid.New().String()
w.Header().Set("X-Request-Id", requestID)
ctx := context.WithValue(r.Context(), handler.RequestIDKey, requestID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func InstanceIDMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", instanceID)
next.ServeHTTP(w, r)
})
}
func main() {
dbURL := os.Getenv("DATABASE_URL")
if dbURL == "" {
dbURL = "postgres://lab3:lab3@postgres:5432/lab3?sslmode=disable&timezone=UTC"
}
log.Printf("INFO: [%s] connecting to PostgreSQL...", instanceID)
pgStore, err := store.NewPostgres(dbURL)
if err != nil {
log.Fatalf("ERROR: failed to connect to database: %v", err)
}
defer pgStore.Close()
log.Printf("INFO: [%s] PostgreSQL connected, migrations applied", instanceID)
redisURL := os.Getenv("REDIS_URL")
if redisURL == "" {
redisURL = "redis://redis:6379/0"
}
sessionTTL := 24 * time.Hour
if s := os.Getenv("SESSION_TTL_SECONDS"); s != "" {
if secs, err := strconv.Atoi(s); err == nil && secs > 0 {
sessionTTL = time.Duration(secs) * time.Second
}
}
log.Printf("INFO: [%s] connecting to Redis (TTL=%v)...", instanceID, sessionTTL)
redisStore, err := session.NewRedisStore(redisURL, sessionTTL)
if err != nil {
log.Fatalf("ERROR: failed to connect to Redis: %v", err)
}
defer redisStore.Close()
log.Printf("INFO: [%s] Redis connected", instanceID)
h := handler.New(pgStore, redisStore, sessionTTL)
r := chi.NewRouter()
r.Use(InstanceIDMiddleware)
r.Use(RequestIDMiddleware)
r.Use(middleware.RealIP)
r.Use(middleware.Recoverer)
r.Use(func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
next.ServeHTTP(w, r)
rid, _ := r.Context().Value(handler.RequestIDKey).(string)
log.Printf("INFO: [%s] %s %s %v [request_id=%s]", instanceID, r.Method, r.URL.Path, time.Since(start), rid)
})
})
r.Get("/health/live", h.HealthLive)
r.Get("/health/ready", h.HealthReady)
r.Route("/api/v1", func(r chi.Router) {
r.Post("/users", h.CreateUser)
r.Post("/auth/sessions", h.CreateSession)
r.Group(func(r chi.Router) {
r.Use(h.BearerAuthMiddleware)
r.Delete("/auth/sessions/current", h.DeleteSession)
r.Get("/users/me", h.GetMe)
r.Get("/chats", h.ListChats)
r.Post("/chats", h.CreateChat)
r.Get("/chats/{chat_id}", h.GetChat)
r.Post("/chats/{chat_id}/messages", h.SendMessage)
r.Get("/chats/{chat_id}/messages", h.GetMessages)
})
})
r.NotFound(func(w http.ResponseWriter, r *http.Request) {
rid, _ := r.Context().Value(handler.RequestIDKey).(string)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusNotFound)
w.Write([]byte(`{"error":{"code":"not_found","message":"Not Found","request_id":"` + rid + `"}}`))
})
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
srv := &http.Server{
Addr: "0.0.0.0:" + port,
Handler: r,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 15 * time.Second,
}
go func() {
log.Printf("INFO: [%s] server starting on port %s", instanceID, port)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("ERROR: [%s] server failed: %v", instanceID, err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Printf("INFO: [%s] shutting down...", instanceID)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.SetKeepAlivesEnabled(false)
if err := srv.Shutdown(ctx); err != nil {
log.Fatalf("ERROR: [%s] forced shutdown: %v", instanceID, err)
}
log.Printf("INFO: [%s] exited properly", instanceID)
}
+46
View File
@@ -0,0 +1,46 @@
package auth
import (
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"time"
"golang.org/x/crypto/bcrypt"
)
func HashPassword(password string) (string, error) {
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
return "", err
}
return string(hash), nil
}
func CheckPassword(password, hash string) bool {
err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
return err == nil
}
func GenerateToken() (string, error) {
b := make([]byte, 32)
if _, err := rand.Read(b); err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(b), nil
}
func HashToken(token string) string {
h := sha256.Sum256([]byte(token))
return hex.EncodeToString(h[:])
}
func SecureCompare(a, b string) bool {
return subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1
}
func IsSessionExpired(expiresAt time.Time) bool {
return time.Now().After(expiresAt)
}
+401
View File
@@ -0,0 +1,401 @@
package handler
import (
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"log"
"net/http"
"strconv"
"strings"
"time"
"mtusi2026lab3-fork/src/internal/auth"
"mtusi2026lab3-fork/src/internal/model"
"mtusi2026lab3-fork/src/internal/store"
"github.com/go-chi/chi/v5"
)
type CtxKey string
const RequestIDKey CtxKey = "request_id"
const UserIDKey CtxKey = "user_id"
type SessionStore interface {
Get(ctx context.Context, tokenHash string) (string, error)
Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error
Delete(ctx context.Context, tokenHash string) error
}
type Handler struct {
store store.Store
sessionStore SessionStore
sessionTTL time.Duration
}
func New(s store.Store, ss SessionStore, ttl time.Duration) *Handler {
return &Handler{store: s, sessionStore: ss, sessionTTL: ttl}
}
func userToMap(u *model.User) map[string]interface{} {
return map[string]interface{}{
"id": u.ID,
"username": u.Username,
"display_name": u.DisplayName,
"created_at": u.CreatedAt.UTC().Format(time.RFC3339),
}
}
func respondError(w http.ResponseWriter, r *http.Request, code int, errorCode string) {
requestID, _ := r.Context().Value(RequestIDKey).(string)
log.Printf("ERROR: %d - %s [request_id=%s]", code, errorCode, requestID)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
json.NewEncoder(w).Encode(map[string]interface{}{
"error": map[string]string{"code": errorCode, "message": http.StatusText(code), "request_id": requestID},
})
}
func respondJSON(w http.ResponseWriter, code int, data interface{}) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
json.NewEncoder(w).Encode(data)
}
func checkContentType(r *http.Request) bool {
ct := r.Header.Get("Content-Type")
return ct == "application/json" || strings.HasPrefix(ct, "application/json;")
}
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
if !checkContentType(r) {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
var req struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if len(req.Password) < 12 || len(req.Password) > 128 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
pwHash, err := auth.HashPassword(req.Password)
if err != nil {
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
user, err := h.store.CreateUser(r.Context(), req.Username, req.DisplayName, pwHash)
if err != nil {
if errors.Is(err, store.ErrConflict) {
respondError(w, r, http.StatusConflict, "conflict")
} else {
respondError(w, r, http.StatusBadRequest, "invalid_request")
}
return
}
respondJSON(w, http.StatusCreated, userToMap(user))
}
func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if !strings.HasPrefix(authHeader, "Basic ") {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
payload, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(authHeader, "Basic "))
if err != nil {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
parts := strings.SplitN(string(payload), ":", 2)
if len(parts) != 2 {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
username, password := parts[0], parts[1]
user, err := h.store.GetUserByUsername(r.Context(), username)
if err != nil || !auth.CheckPassword(password, user.PasswordHash) {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
token, err := auth.GenerateToken()
if err != nil {
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
tokenHash := auth.HashToken(token)
expiresAt := time.Now().Add(h.sessionTTL)
if err := h.sessionStore.Set(r.Context(), user.ID, tokenHash, h.sessionTTL); err != nil {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
_, _ = h.store.CreateSession(r.Context(), user.ID, tokenHash, expiresAt)
respondJSON(w, http.StatusCreated, map[string]interface{}{
"token": token,
"token_type": "Bearer",
"expires_at": expiresAt.UTC().Format(time.RFC3339),
"user": userToMap(user),
})
}
func (h *Handler) DeleteSession(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if !strings.HasPrefix(authHeader, "Bearer ") {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
token := strings.TrimPrefix(authHeader, "Bearer ")
tokenHash := auth.HashToken(token)
if err := h.store.DeleteSession(r.Context(), tokenHash); err != nil {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
if err := h.sessionStore.Delete(r.Context(), tokenHash); err != nil {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
w.WriteHeader(http.StatusNoContent)
}
func (h *Handler) BearerAuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if !strings.HasPrefix(authHeader, "Bearer ") {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
tokenHash := auth.HashToken(strings.TrimPrefix(authHeader, "Bearer "))
userID, err := h.sessionStore.Get(r.Context(), tokenHash)
if err != nil {
sess, errPg := h.store.GetSession(r.Context(), tokenHash)
if errPg != nil || auth.IsSessionExpired(sess.ExpiresAt) {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
userID = sess.UserID
}
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), UserIDKey, userID)))
})
}
func (h *Handler) GetMe(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
user, err := h.store.GetUserByID(r.Context(), userID)
if err != nil {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
respondJSON(w, http.StatusOK, userToMap(user))
}
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
if !checkContentType(r) {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
var req struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
isMember := false
for _, id := range req.MemberIDs {
if id == userID {
isMember = true
break
}
}
if !isMember {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
chat, err := h.store.CreateChat(r.Context(), req.Title, req.MemberIDs)
if err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if chat.MemberIDs == nil {
chat.MemberIDs = []string{}
}
respondJSON(w, http.StatusCreated, chat)
}
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
limit := 50
if ls := r.URL.Query().Get("limit"); ls != "" {
p, err := strconv.Atoi(ls)
if err != nil || p < 1 || p > 100 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
limit = p
}
chats, nextCursor, err := h.store.ListChats(r.Context(), userID, limit, r.URL.Query().Get("cursor"))
if err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if chats == nil {
chats = []*model.Chat{}
}
for _, c := range chats {
if c.MemberIDs == nil {
c.MemberIDs = []string{}
}
}
respondJSON(w, http.StatusOK, map[string]interface{}{"items": chats, "next_cursor": nextCursor})
}
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
chat, err := h.store.GetChat(r.Context(), chi.URLParam(r, "chat_id"), userID)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusNotFound, "not_found")
} else {
respondError(w, r, http.StatusBadRequest, "invalid_request")
}
return
}
if chat.MemberIDs == nil {
chat.MemberIDs = []string{}
}
respondJSON(w, http.StatusOK, chat)
}
// SendMessage — лаба 3: обязателен Idempotency-Key.
func (h *Handler) SendMessage(w http.ResponseWriter, r *http.Request) {
if !checkContentType(r) {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
idemKey := r.Header.Get("Idempotency-Key")
if idemKey == "" || len(idemKey) > 255 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
chatID := chi.URLParam(r, "chat_id")
var req struct {
Text string `json:"text"`
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
// Канонический хеш тела: только значимые поля, стабильный порядок.
canonical, _ := json.Marshal(map[string]string{"text": req.Text})
requestHash := sha256Hex(canonical)
path := "/api/v1/chats/" + chatID + "/messages"
msg, err := h.store.SendMessageIdempotent(r.Context(), chatID, userID, req.Text, idemKey, path, requestHash)
if err != nil {
switch {
case errors.Is(err, store.ErrConflict):
respondError(w, r, http.StatusConflict, "conflict")
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
default:
respondError(w, r, http.StatusBadRequest, "invalid_request")
}
return
}
respondJSON(w, http.StatusCreated, msg)
}
func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
limit := 50
if ls := r.URL.Query().Get("limit"); ls != "" {
p, err := strconv.Atoi(ls)
if err != nil || p < 1 || p > 100 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
limit = p
}
messages, nextCursor, err := h.store.GetMessages(r.Context(), chi.URLParam(r, "chat_id"), userID, r.URL.Query().Get("cursor"), limit)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusNotFound, "not_found")
} else {
respondError(w, r, http.StatusBadRequest, "invalid_request")
}
return
}
if messages == nil {
messages = []*model.Message{}
}
respondJSON(w, http.StatusOK, map[string]interface{}{"items": messages, "next_cursor": nextCursor})
}
func (h *Handler) HealthLive(w http.ResponseWriter, r *http.Request) {
respondJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (h *Handler) HealthReady(w http.ResponseWriter, r *http.Request) {
respondJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func sha256Hex(b []byte) string {
h := sha256.Sum256(b)
return hex.EncodeToString(h[:])
}
+48
View File
@@ -0,0 +1,48 @@
package model
import "time"
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
PasswordHash string `json:"-"`
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 Session struct {
ID string `json:"id"`
UserID string `json:"user_id"`
TokenHash string `json:"-"`
ExpiresAt time.Time `json:"expires_at"`
CreatedAt time.Time `json:"created_at"`
}
// IdempotencyKey — запись ключа идемпотентности для POST сообщений (lab3).
type IdempotencyKey struct {
ID string `json:"id"`
UserID string `json:"user_id"`
Method string `json:"method"`
Path string `json:"path"`
Key string `json:"key"`
RequestHash string `json:"request_hash"`
ResponseCode int `json:"response_code"`
ResponseBody []byte `json:"response_body"`
CreatedAt time.Time `json:"created_at"`
ExpiresAt time.Time `json:"expires_at"`
}
+84
View File
@@ -0,0 +1,84 @@
package session
import (
"context"
"errors"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
var (
ErrSessionNotFound = errors.New("session_not_found")
ErrRedisDown = errors.New("redis_unavailable")
)
// RedisStore реализует handler.SessionStore (Get/Set/Delete).
// Криптография токенов живёт в пакете auth — здесь только хранение.
type RedisStore struct {
client *redis.Client
}
func NewRedisStore(redisURL string, ttl time.Duration) (*RedisStore, error) {
opts, err := redis.ParseURL(redisURL)
if err != nil {
return nil, fmt.Errorf("parse redis url: %w", err)
}
opts.DialTimeout = 3 * time.Second
opts.ReadTimeout = 3 * time.Second
opts.WriteTimeout = 3 * time.Second
opts.PoolSize = 20
opts.MinIdleConns = 5
client := redis.NewClient(opts)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := client.Ping(ctx).Err(); err != nil {
return nil, fmt.Errorf("redis ping: %w", err)
}
return &RedisStore{client: client}, nil
}
func (s *RedisStore) Close() error {
return s.client.Close()
}
func (s *RedisStore) Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error {
key := fmt.Sprintf("session:%s", tokenHash)
if err := s.client.Set(ctx, key, userID, ttl).Err(); err != nil {
return fmt.Errorf("%w: %v", ErrRedisDown, err)
}
return nil
}
func (s *RedisStore) Get(ctx context.Context, tokenHash string) (string, error) {
if tokenHash == "" {
return "", ErrSessionNotFound
}
key := fmt.Sprintf("session:%s", tokenHash)
userID, err := s.client.Get(ctx, key).Result()
if err != nil {
if errors.Is(err, redis.Nil) {
return "", ErrSessionNotFound
}
return "", fmt.Errorf("%w: %v", ErrRedisDown, err)
}
return userID, nil
}
func (s *RedisStore) Delete(ctx context.Context, tokenHash string) error {
key := fmt.Sprintf("session:%s", tokenHash)
if err := s.client.Del(ctx, key).Err(); err != nil {
return fmt.Errorf("%w: %v", ErrRedisDown, err)
}
return nil
}
func (s *RedisStore) IsAvailable(ctx context.Context) bool {
return s.client.Ping(ctx).Err() == nil
}
@@ -0,0 +1,47 @@
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
username VARCHAR(32) NOT NULL UNIQUE,
display_name VARCHAR(100) NOT NULL,
password_hash VARCHAR(255) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$')
);
CREATE INDEX idx_users_username ON users(username);
CREATE TABLE chats (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX idx_chat_members_user ON chat_members(user_id);
CREATE TABLE messages (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000),
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_messages_chat_created ON messages(chat_id, created_at, id);
CREATE TABLE sessions (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
token_hash VARCHAR(64) NOT NULL UNIQUE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_sessions_token ON sessions(token_hash);
CREATE INDEX idx_sessions_user ON sessions(user_id);
CREATE INDEX idx_sessions_expires ON sessions(expires_at);
@@ -0,0 +1,19 @@
CREATE TABLE IF NOT EXISTS idempotency_keys (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
method TEXT NOT NULL,
path TEXT NOT NULL,
key TEXT NOT NULL,
request_hash TEXT NOT NULL, -- SHA-256 hex canonical JSON body
response_code INT NOT NULL,
response_body JSONB NOT NULL, -- сохранённый Message для реплея
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
expires_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + INTERVAL '24 hours',
UNIQUE (user_id, method, path, key)
);
CREATE INDEX IF NOT EXISTS idx_idem_expires ON idempotency_keys (expires_at);
-- Сообщения связываем с ключом, чтобы при реплее вернуть тот же объект
ALTER TABLE messages
ADD COLUMN IF NOT EXISTS idempotency_key_id UUID REFERENCES idempotency_keys(id) ON DELETE SET NULL;
+565
View File
@@ -0,0 +1,565 @@
package store
import (
"context"
"crypto/sha256"
"embed"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"log"
"time"
"mtusi2026lab3-fork/src/internal/model"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
//go:embed migrations/*.sql
var migrationsFS embed.FS
var (
ErrInvalidRequest = errors.New("invalid_request")
ErrNotFound = errors.New("not_found")
ErrConflict = errors.New("conflict")
ErrUnauthorized = errors.New("unauthorized")
)
// Миграционный advisory lock: фиксированный 64-битный ID, чтобы две реплики
// не применяли миграции одновременно.
const migrationAdvisoryLockID int64 = 7272727272727272
type Store interface {
CreateUser(ctx context.Context, username, displayName, passwordHash string) (*model.User, error)
GetUserByID(ctx context.Context, id string) (*model.User, error)
GetUserByUsername(ctx context.Context, username string) (*model.User, error)
CreateChat(ctx context.Context, title string, memberIDs []string) (*model.Chat, error)
GetChat(ctx context.Context, chatID, userID string) (*model.Chat, error)
ListChats(ctx context.Context, userID string, limit int, cursor string) ([]*model.Chat, *string, error)
AddMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error)
SendMessageIdempotent(ctx context.Context, chatID, senderID, text, idemKey, path, requestHash string) (*model.Message, error)
GetMessages(ctx context.Context, chatID, userID, cursor string, limit int) ([]*model.Message, *string, error)
CreateSession(ctx context.Context, userID, tokenHash string, expiresAt time.Time) (*model.Session, error)
GetSession(ctx context.Context, tokenHash string) (*model.Session, error)
DeleteSession(ctx context.Context, tokenHash string) error
}
type PostgresStore struct {
pool *pgxpool.Pool
}
func NewPostgres(connString string) (*PostgresStore, error) {
config, err := pgxpool.ParseConfig(connString)
if err != nil {
return nil, fmt.Errorf("parse config: %w", err)
}
config.MaxConns = 25
config.MinConns = 5
config.MaxConnLifetime = 30 * time.Minute
config.MaxConnIdleTime = 5 * time.Minute
config.HealthCheckPeriod = 30 * time.Second
pool, err := pgxpool.NewWithConfig(context.Background(), config)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := pool.Ping(ctx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping database: %w", err)
}
store := &PostgresStore{pool: pool}
if err := store.applyMigrations(ctx); err != nil {
pool.Close()
return nil, fmt.Errorf("apply migrations: %w", err)
}
return store, nil
}
func (s *PostgresStore) Close() {
s.pool.Close()
}
// applyMigrations сериализован advisory-локом: первая реплика применяет,
// вторая ждёт и видит уже применённые версии (идемпотентно).
func (s *PostgresStore) applyMigrations(ctx context.Context) error {
conn, err := s.pool.Acquire(ctx)
if err != nil {
return fmt.Errorf("acquire conn for lock: %w", err)
}
defer conn.Release()
if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, migrationAdvisoryLockID); err != nil {
return fmt.Errorf("advisory lock: %w", err)
}
defer func() {
_, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, migrationAdvisoryLockID)
}()
_, err = conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
version INTEGER PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)`)
if err != nil {
return fmt.Errorf("create migrations table: %w", err)
}
var lastVersion int
err = conn.QueryRow(ctx, `SELECT COALESCE(MAX(version), 0) FROM schema_migrations`).Scan(&lastVersion)
if err != nil {
return fmt.Errorf("get last version: %w", err)
}
entries, err := migrationsFS.ReadDir("migrations")
if err != nil {
return fmt.Errorf("read migrations: %w", err)
}
for _, entry := range entries {
if entry.IsDir() {
continue
}
var version int
if _, err := fmt.Sscanf(entry.Name(), "%d_", &version); err != nil {
continue
}
if version <= lastVersion {
log.Printf("INFO: Skipping migration %s (already applied)", entry.Name())
continue
}
content, err := migrationsFS.ReadFile("migrations/" + entry.Name())
if err != nil {
return fmt.Errorf("read migration %s: %w", entry.Name(), err)
}
if _, err := conn.Exec(ctx, string(content)); err != nil {
return fmt.Errorf("execute migration %s: %w", entry.Name(), err)
}
if _, err := conn.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, version); err != nil {
return fmt.Errorf("insert migration version: %w", err)
}
log.Printf("INFO: Applied migration %s", entry.Name())
}
return nil
}
func (s *PostgresStore) CreateUser(ctx context.Context, username, displayName, passwordHash string) (*model.User, error) {
var user model.User
query := `INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING id, username, display_name, created_at`
err := s.pool.QueryRow(ctx, query, username, displayName, passwordHash).Scan(
&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt,
)
if err != nil {
if isUniqueViolation(err) {
return nil, ErrConflict
}
return nil, fmt.Errorf("insert user: %w", err)
}
user.CreatedAt = user.CreatedAt.UTC()
return &user, nil
}
func (s *PostgresStore) GetUserByID(ctx context.Context, id string) (*model.User, error) {
var user model.User
query := `SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1`
err := s.pool.QueryRow(ctx, query, id).Scan(
&user.ID, &user.Username, &user.DisplayName, &user.PasswordHash, &user.CreatedAt,
)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get user by id: %w", err)
}
user.CreatedAt = user.CreatedAt.UTC()
return &user, nil
}
func (s *PostgresStore) GetUserByUsername(ctx context.Context, username string) (*model.User, error) {
var user model.User
query := `SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`
err := s.pool.QueryRow(ctx, query, username).Scan(
&user.ID, &user.Username, &user.DisplayName, &user.PasswordHash, &user.CreatedAt,
)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get user by username: %w", err)
}
user.CreatedAt = user.CreatedAt.UTC()
return &user, nil
}
func (s *PostgresStore) CreateChat(ctx context.Context, title string, memberIDs []string) (*model.Chat, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, fmt.Errorf("begin tx: %w", err)
}
defer tx.Rollback(ctx)
var chat model.Chat
if err := tx.QueryRow(ctx, `INSERT INTO chats (title) VALUES ($1) RETURNING id, created_at`, title).
Scan(&chat.ID, &chat.CreatedAt); err != nil {
return nil, fmt.Errorf("insert chat: %w", err)
}
for _, userID := range memberIDs {
if _, err := tx.Exec(ctx, `INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`, chat.ID, userID); err != nil {
return nil, fmt.Errorf("insert member %s: %w", userID, err)
}
}
if err := tx.Commit(ctx); err != nil {
return nil, fmt.Errorf("commit tx: %w", err)
}
chat.Title = title
chat.MemberIDs = memberIDs
if chat.MemberIDs == nil {
chat.MemberIDs = []string{}
}
chat.CreatedAt = chat.CreatedAt.UTC()
return &chat, nil
}
func (s *PostgresStore) GetChat(ctx context.Context, chatID, userID string) (*model.Chat, error) {
var isMember bool
if err := s.pool.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return nil, fmt.Errorf("check membership: %w", err)
}
if !isMember {
return nil, ErrNotFound
}
var chat model.Chat
if err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, chatID).
Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get chat: %w", err)
}
chat.CreatedAt = chat.CreatedAt.UTC()
chat.MemberIDs = []string{}
rows, err := s.pool.Query(ctx, `SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
if err != nil {
return nil, fmt.Errorf("get members: %w", err)
}
defer rows.Close()
for rows.Next() {
var m string
if err := rows.Scan(&m); err != nil {
return nil, fmt.Errorf("scan member: %w", err)
}
chat.MemberIDs = append(chat.MemberIDs, m)
}
return &chat, nil
}
func (s *PostgresStore) ListChats(ctx context.Context, userID string, limit int, cursor string) ([]*model.Chat, *string, error) {
fetchLimit := limit + 1 // +1, чтобы понять, есть ли следующая страница
var query string
var args []interface{}
if cursor == "" {
query = `SELECT c.id, c.title, c.created_at FROM chats c
INNER JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 ORDER BY c.created_at, c.id LIMIT $2`
args = []interface{}{userID, fetchLimit}
} else {
var cursorCreatedAt time.Time
if err := s.pool.QueryRow(ctx, `SELECT created_at FROM chats WHERE id = $1`, cursor).Scan(&cursorCreatedAt); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil, ErrInvalidRequest
}
return nil, nil, fmt.Errorf("get cursor: %w", err)
}
query = `SELECT c.id, c.title, c.created_at FROM chats c
INNER JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2, $3)
ORDER BY c.created_at, c.id LIMIT $4`
args = []interface{}{userID, cursorCreatedAt, cursor, fetchLimit}
}
rows, err := s.pool.Query(ctx, query, args...)
if err != nil {
return nil, nil, fmt.Errorf("query chats: %w", err)
}
defer rows.Close()
var chats []*model.Chat
for rows.Next() {
var chat model.Chat
if err := rows.Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil {
return nil, nil, fmt.Errorf("scan chat: %w", err)
}
chat.CreatedAt = chat.CreatedAt.UTC()
chat.MemberIDs = []string{}
chats = append(chats, &chat)
}
if len(chats) > 0 {
ids := make([]string, len(chats))
for i, c := range chats {
ids[i] = c.ID
}
mrows, err := s.pool.Query(ctx, `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`, ids)
if err != nil {
return nil, nil, fmt.Errorf("query members: %w", err)
}
defer mrows.Close()
mm := make(map[string][]string)
for mrows.Next() {
var cid, mid string
if err := mrows.Scan(&cid, &mid); err != nil {
return nil, nil, fmt.Errorf("scan member: %w", err)
}
mm[cid] = append(mm[cid], mid)
}
for _, c := range chats {
if members, ok := mm[c.ID]; ok {
c.MemberIDs = members
}
}
}
var nextCursor *string
if len(chats) > limit {
chats = chats[:limit]
lastID := chats[len(chats)-1].ID
nextCursor = &lastID
}
if chats == nil {
chats = []*model.Chat{}
}
return chats, nextCursor, nil
}
func (s *PostgresStore) AddMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error) {
return s.insertMessage(ctx, chatID, senderID, text)
}
func (s *PostgresStore) SendMessageIdempotent(ctx context.Context, chatID, senderID, text, idemKey, path, requestHash string) (*model.Message, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, fmt.Errorf("begin tx: %w", err)
}
defer tx.Rollback(ctx)
scope := fmt.Sprintf("%s|%s|%s|%s", senderID, "POST", path, idemKey)
lockID := int64(hashScope(scope))
if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock($1)`, lockID); err != nil {
return nil, fmt.Errorf("advisory xact lock: %w", err)
}
var existingHash string
var existingBody []byte
err = tx.QueryRow(ctx,
`SELECT request_hash, response_body FROM idempotency_keys
WHERE user_id = $1 AND method = $2 AND path = $3 AND key = $4`,
senderID, "POST", path, idemKey).Scan(&existingHash, &existingBody)
switch {
case err == nil:
if existingHash != requestHash {
return nil, ErrConflict
}
var msg model.Message
if err := json.Unmarshal(existingBody, &msg); err != nil {
return nil, fmt.Errorf("decode replay body: %w", err)
}
msg.CreatedAt = msg.CreatedAt.UTC()
return &msg, nil
case errors.Is(err, pgx.ErrNoRows):
msg, err := s.insertMessageTx(ctx, tx, chatID, senderID, text)
if err != nil {
return nil, err
}
body, _ := json.Marshal(msg)
if _, err := tx.Exec(ctx,
`INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, response_code, response_body)
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
senderID, "POST", path, idemKey, requestHash, 201, body); err != nil {
return nil, fmt.Errorf("insert idempotency key: %w", err)
}
if err := tx.Commit(ctx); err != nil {
return nil, fmt.Errorf("commit tx: %w", err)
}
return msg, nil
default:
return nil, fmt.Errorf("select idempotency key: %w", err)
}
}
func (s *PostgresStore) insertMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error) {
var isMember bool
if err := s.pool.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, senderID).Scan(&isMember); err != nil {
return nil, fmt.Errorf("check membership: %w", err)
}
if !isMember {
return nil, ErrNotFound
}
var msg model.Message
if err := s.pool.QueryRow(ctx,
`INSERT INTO messages (chat_id, sender_id, text) VALUES ($1, $2, $3)
RETURNING id, chat_id, sender_id, text, created_at`,
chatID, senderID, text).
Scan(&msg.ID, &msg.ChatID, &msg.SenderID, &msg.Text, &msg.CreatedAt); err != nil {
return nil, fmt.Errorf("insert message: %w", err)
}
msg.CreatedAt = msg.CreatedAt.UTC()
return &msg, nil
}
func (s *PostgresStore) insertMessageTx(ctx context.Context, tx pgx.Tx, chatID, senderID, text string) (*model.Message, error) {
var isMember bool
if err := tx.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, senderID).Scan(&isMember); err != nil {
return nil, fmt.Errorf("check membership: %w", err)
}
if !isMember {
return nil, ErrNotFound
}
var msg model.Message
if err := tx.QueryRow(ctx,
`INSERT INTO messages (chat_id, sender_id, text) VALUES ($1, $2, $3)
RETURNING id, chat_id, sender_id, text, created_at`,
chatID, senderID, text).
Scan(&msg.ID, &msg.ChatID, &msg.SenderID, &msg.Text, &msg.CreatedAt); err != nil {
return nil, fmt.Errorf("insert message: %w", err)
}
msg.CreatedAt = msg.CreatedAt.UTC()
return &msg, nil
}
func (s *PostgresStore) GetMessages(ctx context.Context, chatID, userID, cursor string, limit int) ([]*model.Message, *string, error) {
var isMember bool
if err := s.pool.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return nil, nil, fmt.Errorf("check membership: %w", err)
}
if !isMember {
return nil, nil, ErrNotFound
}
fetchLimit := limit + 1 // +1 для определения наличия下一页
var query string
var args []interface{}
if cursor == "" {
query = `SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 ORDER BY created_at, id LIMIT $2`
args = []interface{}{chatID, fetchLimit}
} else {
var cAt time.Time
if err := s.pool.QueryRow(ctx, `SELECT created_at FROM messages WHERE id = $1 AND chat_id = $2`, cursor, chatID).Scan(&cAt); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil, ErrInvalidRequest
}
return nil, nil, fmt.Errorf("get cursor: %w", err)
}
query = `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`
args = []interface{}{chatID, cAt, cursor, fetchLimit}
}
rows, err := s.pool.Query(ctx, query, args...)
if err != nil {
return nil, nil, fmt.Errorf("query messages: %w", err)
}
defer rows.Close()
var messages []*model.Message
for rows.Next() {
var msg model.Message
if err := rows.Scan(&msg.ID, &msg.ChatID, &msg.SenderID, &msg.Text, &msg.CreatedAt); err != nil {
return nil, nil, fmt.Errorf("scan message: %w", err)
}
msg.CreatedAt = msg.CreatedAt.UTC()
messages = append(messages, &msg)
}
// Ключевой фикс: история «заканчивается» ровно тогда, когда выбрали <= limit
var nextCursor *string
if len(messages) > limit {
messages = messages[:limit]
lastID := messages[len(messages)-1].ID
nextCursor = &lastID
}
if messages == nil {
messages = []*model.Message{}
}
return messages, nextCursor, nil
}
func (s *PostgresStore) CreateSession(ctx context.Context, userID, tokenHash string, expiresAt time.Time) (*model.Session, error) {
var session model.Session
if err := s.pool.QueryRow(ctx,
`INSERT INTO sessions (user_id, token_hash, expires_at) VALUES ($1, $2, $3)
RETURNING id, user_id, token_hash, expires_at, created_at`,
userID, tokenHash, expiresAt).
Scan(&session.ID, &session.UserID, &session.TokenHash, &session.ExpiresAt, &session.CreatedAt); err != nil {
return nil, fmt.Errorf("insert session: %w", err)
}
session.ExpiresAt = session.ExpiresAt.UTC()
session.CreatedAt = session.CreatedAt.UTC()
return &session, nil
}
func (s *PostgresStore) GetSession(ctx context.Context, tokenHash string) (*model.Session, error) {
var session model.Session
if err := s.pool.QueryRow(ctx,
`SELECT id, user_id, token_hash, expires_at, created_at FROM sessions WHERE token_hash = $1 AND expires_at > NOW()`,
tokenHash).
Scan(&session.ID, &session.UserID, &session.TokenHash, &session.ExpiresAt, &session.CreatedAt); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get session: %w", err)
}
session.ExpiresAt = session.ExpiresAt.UTC()
session.CreatedAt = session.CreatedAt.UTC()
return &session, nil
}
func (s *PostgresStore) DeleteSession(ctx context.Context, tokenHash string) error {
if _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, tokenHash); err != nil {
return fmt.Errorf("delete session: %w", err)
}
return nil
}
func hashScope(s string) uint32 {
h := sha256.Sum256([]byte(s))
return uint32(h[0])<<24 | uint32(h[1])<<16 | uint32(h[2])<<8 | uint32(h[3])
}
func isUniqueViolation(err error) bool {
return err != nil && (contains(err.Error(), "23505") || contains(err.Error(), "duplicate key"))
}
func contains(s, substr string) bool {
for i := 0; i+len(substr) <= len(s); i++ {
if s[i:i+len(substr)] == substr {
return true
}
}
return false
}
var _ = hex.EncodeToString // подавление unused-импорта, если hex не нужен; удали строку и импорт hex, если компилятор ругается
+125
View File
@@ -0,0 +1,125 @@
#!/usr/bin/env python3
"""Student tests lab2. Запуск: python3 student-tests/run-test.py [--base-url URL]"""
import argparse
import base64
import json
import sys
import urllib.error
import urllib.request
import uuid
BASE = "http://localhost:8080"
FAILURES = []
def req(method, path, body=None, raw=None, token=None, ctype="application/json"):
headers, data = {}, None
if raw is not None:
data, headers["Content-Type"] = raw.encode("utf-8"), ctype
elif body is not None:
data, headers["Content-Type"] = json.dumps(body, ensure_ascii=False).encode("utf-8"), ctype
if token:
if token.startswith("Basic "):
headers["Authorization"] = token
else:
headers["Authorization"] = f"Bearer {token}"
r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(r, timeout=30) as resp:
payload = resp.read().decode("utf-8")
return resp.status, dict(resp.headers), (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read().decode("utf-8")
try:
return e.code, dict(e.headers), json.loads(payload)
except ValueError:
return e.code, dict(e.headers), None
def check(name, cond, detail=""):
if not cond:
FAILURES.append(name)
print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else ""))
def register_user(username, display_name, password):
st, _, body = req("POST", "/api/v1/users", {"username": username, "display_name": display_name, "password": password})
assert st == 201, f"cannot create user: {st} {body}"
return body
def login(username, password):
creds = base64.b64encode(f"{username}:{password}".encode()).decode()
st, _, body = req("POST", "/api/v1/auth/sessions", token=f"Basic {creds}")
assert st == 201, f"cannot login: {st} {body}"
return body # Возвращаем весь словарь ответа
def main():
global BASE
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
BASE = ap.parse_args().base_url.rstrip("/")
# Health checks
st, hdr, body = req("GET", "/health/live")
check("health live 200", st == 200 and body == {"status": "ok"})
check("X-Request-Id present", bool(hdr.get("X-Request-Id")))
# Validation tests
st, _, body = req("POST", "/api/v1/users", raw='{"username": "abc",')
check("malformed JSON -> 400", st == 400 and body["error"]["code"] == "invalid_request")
st, _, _ = req("POST", "/api/v1/users", {"username": "BadName", "display_name": "x", "password": "validpassword123"})
check("username pattern -> 400", st == 400)
# Registration & Login
pwd = "SecurePassword123!"
alice = register_user("alice" + uuid.uuid4().hex[:6], "Алиса", pwd)
bob = register_user("bob" + uuid.uuid4().hex[:6], "Боб", pwd)
st, _, body = req("POST", "/api/v1/users", {"username": alice["username"], "display_name": "dup", "password": pwd})
check("duplicate username -> 409", st == 409 and body["error"]["code"] == "conflict")
# ИСПРАВЛЕНО: Достаем токен из словаря ответа
alice_login_resp = login(alice["username"], pwd)
alice_token = alice_login_resp["token"]
check("login returns token", "token" in alice_login_resp and "user" in alice_login_resp)
# Auth checks
st, _, body = req("GET", "/api/v1/users/me")
check("no token -> 401", st == 401 and body["error"]["code"] == "unauthorized")
st, _, body = req("GET", "/api/v1/users/me", token="invalid_token")
check("invalid token -> 401", st == 401)
# Chat & Messages
st, _, chat = req("POST", "/api/v1/chats", {"title": "Чат", "member_ids": [alice["id"], bob["id"]]}, token=alice_token)
check("create chat 201", st == 201)
st, _, body = req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "Привет"}, token=alice_token)
check("send message 201", st == 201 and body["text"] == "Привет")
st, _, body = req("GET", f"/api/v1/chats/{chat['id']}/messages?limit=10", token=alice_token)
check("get messages 200", st == 200 and len(body["items"]) == 1)
# Outsider check
eve = register_user("eve" + uuid.uuid4().hex[:6], "Ева", pwd)
eve_login_resp = login(eve["username"], pwd)
eve_token = eve_login_resp["token"] # ИСПРАВЛЕНО
st, _, body = req("GET", f"/api/v1/chats/{chat['id']}", token=eve_token)
check("outsider GET chat -> 404", st == 404 and body["error"]["code"] == "not_found")
# Logout (Путь согласно openapi.json: /auth/sessions/current)
st, _, _ = req("DELETE", "/api/v1/auth/sessions/current", token=alice_token)
check("logout 204", st == 204)
st, _, body = req("GET", "/api/v1/users/me", token=alice_token)
check("token revoked -> 401", st == 401)
print()
if FAILURES:
print(f"FAILED {len(FAILURES)}: {FAILURES}")
sys.exit(1)
print("ALL STUDENT TESTS PASSED")
if __name__ == "__main__":
main()