From 55788bb8238c40866aa4b72f1624c683702bb9e8 Mon Sep 17 00:00:00 2001 From: Rakshasa2 Date: Wed, 21 Oct 2026 14:00:40 +0300 Subject: [PATCH 1/2] =?UTF-8?q?lab3-=20=D0=BE=D1=86=D0=B5=D0=BD=D0=BA?= =?UTF-8?q?=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 27 + REPORT.md | 115 +++- docker-compose.yml | 97 +++ infra/haproxy.cfg | 30 + scripts/restart.sh | 12 + src/cmd/server/main.go | 152 +++++ src/internal/auth/auth.go | 46 ++ src/internal/handler/handler.go | 401 +++++++++++++ src/internal/model/model.go | 48 ++ src/internal/session/redis_store.go | 84 +++ src/internal/store/migrations/001_initial.sql | 47 ++ .../store/migrations/002_idempotency.sql | 19 + src/internal/store/postgres.go | 565 ++++++++++++++++++ student-tests/run-test.py | 125 ++++ 14 files changed, 1747 insertions(+), 21 deletions(-) create mode 100644 Dockerfile create mode 100644 docker-compose.yml create mode 100644 infra/haproxy.cfg create mode 100755 scripts/restart.sh create mode 100644 src/cmd/server/main.go create mode 100644 src/internal/auth/auth.go create mode 100644 src/internal/handler/handler.go create mode 100644 src/internal/model/model.go create mode 100644 src/internal/session/redis_store.go create mode 100644 src/internal/store/migrations/001_initial.sql create mode 100644 src/internal/store/migrations/002_idempotency.sql create mode 100644 src/internal/store/postgres.go create mode 100644 student-tests/run-test.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..110588c4 --- /dev/null +++ b/Dockerfile @@ -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"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index c2679005..77c17aa7 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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‑про \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 00000000..2bbbbb74 --- /dev/null +++ b/docker-compose.yml @@ -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: \ No newline at end of file diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..fe761c24 --- /dev/null +++ b/infra/haproxy.cfg @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..946a86d8 --- /dev/null +++ b/scripts/restart.sh @@ -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 \ No newline at end of file diff --git a/src/cmd/server/main.go b/src/cmd/server/main.go new file mode 100644 index 00000000..c386ad02 --- /dev/null +++ b/src/cmd/server/main.go @@ -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) +} diff --git a/src/internal/auth/auth.go b/src/internal/auth/auth.go new file mode 100644 index 00000000..57942bb3 --- /dev/null +++ b/src/internal/auth/auth.go @@ -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) +} diff --git a/src/internal/handler/handler.go b/src/internal/handler/handler.go new file mode 100644 index 00000000..0bf94ef7 --- /dev/null +++ b/src/internal/handler/handler.go @@ -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[:]) +} diff --git a/src/internal/model/model.go b/src/internal/model/model.go new file mode 100644 index 00000000..54e7e060 --- /dev/null +++ b/src/internal/model/model.go @@ -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"` +} diff --git a/src/internal/session/redis_store.go b/src/internal/session/redis_store.go new file mode 100644 index 00000000..9b7c8873 --- /dev/null +++ b/src/internal/session/redis_store.go @@ -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 +} diff --git a/src/internal/store/migrations/001_initial.sql b/src/internal/store/migrations/001_initial.sql new file mode 100644 index 00000000..f06a5643 --- /dev/null +++ b/src/internal/store/migrations/001_initial.sql @@ -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); \ No newline at end of file diff --git a/src/internal/store/migrations/002_idempotency.sql b/src/internal/store/migrations/002_idempotency.sql new file mode 100644 index 00000000..2031428d --- /dev/null +++ b/src/internal/store/migrations/002_idempotency.sql @@ -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; \ No newline at end of file diff --git a/src/internal/store/postgres.go b/src/internal/store/postgres.go new file mode 100644 index 00000000..ed0d5305 --- /dev/null +++ b/src/internal/store/postgres.go @@ -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, если компилятор ругается diff --git a/student-tests/run-test.py b/student-tests/run-test.py new file mode 100644 index 00000000..c8c39f0d --- /dev/null +++ b/student-tests/run-test.py @@ -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() \ No newline at end of file -- 2.54.0 From b758e184081d399b6098ae7c2577bbe3861da85f Mon Sep 17 00:00:00 2001 From: Rakshasa2 Date: Fri, 23 Oct 2026 15:14:57 +0300 Subject: [PATCH 2/2] =?UTF-8?q?lab3-=20=D0=BE=D1=86=D0=B5=D0=BD=D0=BA?= =?UTF-8?q?=D0=B0=204=20fixed?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- go.mod | 21 +++++++++++++++++++++ go.sum | 42 ++++++++++++++++++++++++++++++++++++++++++ scripts/stop-one.sh | 31 +++++++++++++++++++++++++++++++ 3 files changed, 94 insertions(+) create mode 100644 go.mod create mode 100644 go.sum create mode 100755 scripts/stop-one.sh diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..6cafb913 --- /dev/null +++ b/go.mod @@ -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 +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..d2e58f53 --- /dev/null +++ b/go.sum @@ -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= diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..68037e09 --- /dev/null +++ b/scripts/stop-one.sh @@ -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 -- 2.54.0