Author SHA1 Message Date
Rakshasa2 bf8da2b7d9 lab4 - fixed 2026-11-05 13:37:38 +03:00
Rakshasa2 8c7375a6ea lab4 - оценка 4 2026-10-26 18:17:12 +03:00
Rakshasa2 aea79e8ed7 lab4 - оценка 4 2026-10-26 18:16:58 +03:00
21 changed files with 3099 additions and 20 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"]
+79 -20
View File
@@ -1,37 +1,96 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа:** Тюрина Александра, БВТ2304
- **Целевая оценка:** 4 (Трек 5 не заявлен)
- **Commit/PR:** rakshasa/mtusi2026lab4-форк`, ветка `solution/BVT2304-Tyurina`.
- **Использованные источники, библиотеки и помощь ИИ:**
- Язык и библиотеки: Go 1.22, `github.com/go-chi/chi/v5`, `github.com/jackc/pgx/v5`, `github.com/redis/go-redis/v9`, `github.com/minio/minio-go/v7` (для S3-совместимого клиента), `golang.org/x/crypto/bcrypt`.
- Инфраструктура: HAProxy 2.9, PostgreSQL 16, Redis 7, RustFS (S3-совместимое хранилище).
- Помощь ИИ: использовалась для архитектурного ревью (паттерн компенсации при загрузке в S3), отладки проблемы отмены контекста при потоковой отдаче файлов (`io.Copy` + `context`), исправления точности пагинации (`RFC3339Nano`) и структурирования данного отчёта. Весь код написан и проверен автором.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:** Docker Engine + Compose v2, Python 3.9+, `make`, `curl`. Локальный Go не требуется для запуска стенда.
**1. Создание локальных секретов:**
```bash
cp .env.example .env
# Файл .env находится в .gitignore и не коммитится.
# Секреты S3 и БД уже прописаны в .env.example как учебные значения.
```
**2. Валидация и запуск стенда:**
```bash
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
```
**3. Ожидание готовности:**
```bash
until docker compose ps --format '{{.Name}} {{.Status}}' | grep -q 'lb.*healthy'; do
sleep 1
done
# Дополнительно проверяем, что s3-init успешно завершил работу (Exited 0)
docker compose ps s3-init
```
**4. Запуск тестов:**
```bash
make test
```
**5. Безопасная остановка (данные сохраняются):**
```bash
docker compose --env-file .env down
```
**6. Намеренное удаление учебных данных (очистка volumes):**
```bash
docker compose --env-file .env down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Схема процессов и хранилищ:**
Клиент → HAProxy (`127.0.0.1:8080`, roundrobin, active health-check `inter 2s fall 3`) → API (2 реплики).
API взаимодействует с:
- **PostgreSQL**: источник истины для метаданных (пользователи, чаты, сообщения, метаданные вложений, сессии).
- **Redis**: кэш сессий для быстрого пути (с fallback в PostgreSQL при недоступности).
- **RustFS**: приватное S3-совместимое хранилище для бинарных данных (оригиналы изображений).
**Транзакционные границы и согласованность:**
- **Идемпотентность сообщений:** Реализована через `pg_advisory_xact_lock` по хешу `(user_id, method, path, key)`. Это гарантирует, что конкурентные запросы с одним ключом, попавшие на разные реплики, сериализуются на стороне БД.
- **Загрузка вложений (2PC-подобный паттерн):**
1. Создание записи в БД со статусом `uploading`.
2. `PUT` байтов в RustFS.
3. Если `PUT` успешен, обновление статуса в БД на `ready`.
4. **Компенсация:** Если `PUT` в S3 падает, строка `uploading` удаляется из БД. Если БД не успевает обновить статус на `ready` (например, падение процесса), фоновый reconciler (с grace period 600с) помечает такие записи как `failed` и удаляет "осиротевшие" объекты из S3, предотвращая утечки места.
**Что перенесено из lab3:** Балансировщик, 2 реплики API, общая БД, Redis-кэш сессий, идемпотентность сообщений, keyset-пагинация, graceful shutdown.
**Что изменено/добавлено:** Модель `Attachment`, связь `message_attachments`, эндпоинты загрузки/скачивания бинарных файлов, S3-клиент, проверка magic bytes и лимитов (10 MiB, 40M пикселей) до полной декодировки изображения.
**Соответствие .env:** Все переменные (`DATABASE_URL`, `REDIS_URL`, `S3_ENDPOINT`, `S3_ACCESS_KEY_ID` и т.д.) маппятся напрямую из `.env` в `compose.yaml` и читаются приложением через `os.Getenv`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| **Публичный smoke** | `make test` | `PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.` | `evidence/smoke_pass.txt` |
| **Уровень 3: Балансировка и сессии** | `curl -s -D - -o /dev/null http://localhost:8080/health/live \| grep -i x-instance-id` (x6) | Чередование двух разных `X-Instance-Id`, сессия сохраняется при переходе между репликами. | `evidence/lb_instances.txt` |
| **Уровень 4: Лимиты и валидация (413/415)** | `curl -X POST .../attachments --data-binary @<файл >10MB или с подмененным MIME` | Возвращает `413 Payload Too Large` или `415 Unsupported Media Type`, не `500`. | `evidence/attachment_limits.txt` |
| **Уровень 4: Чужое вложение (404)** | Попытка отправить сообщение с `attachment_ids`, принадлежащим другому чату. | Возвращает `404 Not Found` (проверка принадлежности на уровне БД). | `evidence/foreign_attachment.txt` |
| **Уровень 4: Приватность S3** | Прямой неаутентифицированный `GET` к объекту в RustFS в обход API. | Возвращает `403 Forbidden` (bucket настроен как private). | `evidence/s3_private_access.txt` |
| **Уровень 4: Отказоустойчивость** | Загрузка файла на API-1 → `scripts/stop-one.sh` → скачивание через LB. | Файл успешно скачивается через оставшуюся API-2, SHA-256 совпадает с оригиналом. | `evidence/failover_download.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
**Какие отказы выдерживаются:**
- Падение одной API-реплики (трафик переключается, сессии и данные сохраняются).
- Временная недоступность Redis (автоматический fallback на чтение сессий из PostgreSQL).
- Ошибки сети при загрузке в S3 (компенсация на уровне приложения).
**Какие отказы НЕ выдерживаются (учебные упрощения):**
- **PostgreSQL:** Является единой точкой отказа (SPOF). Репликация БД не настроена в рамках этой лабы.
- **RustFS:** Хранится на одном Docker volume. Потеря хоста приведёт к потере бинарных данных (отсутствует S3-репликация на уровне лабы).
- **Один Docker-host:** Эксперименты не доказывают отказоустойчивость к потере всей машины.
+151
View File
@@ -0,0 +1,151 @@
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: "${SESSION_TTL_SECONDS:-3600}"
IDEMPOTENCY_TTL_SECONDS: "${IDEMPOTENCY_TTL_SECONDS:-86400}"
S3_ENDPOINT: "${S3_ENDPOINT:-http://s3:9000}"
S3_REGION: "${S3_REGION:-us-east-1}"
S3_BUCKET: "${S3_BUCKET:-messenger-attachments}"
S3_ACCESS_KEY_ID: "${S3_ACCESS_KEY_ID}"
S3_SECRET_ACCESS_KEY: "${S3_SECRET_ACCESS_KEY}"
S3_USE_SSL: "${S3_USE_SSL:-false}"
MAX_UPLOAD_BYTES: "${MAX_UPLOAD_BYTES:-10485760}"
MAX_IMAGE_PIXELS: "${MAX_IMAGE_PIXELS:-40000000}"
ATTACHMENT_GRACE_SECONDS: "${ATTACHMENT_GRACE_SECONDS:-600}"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
s3:
condition: service_started
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/health/ready"]
interval: 5s
timeout: 3s
start_period: 15s
retries: 5
deploy:
replicas: 2
resources:
limits:
cpus: "0.50"
memory: 512M
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
s3:
image: rustfs/rustfs@sha256:ed9210d6411d77ffceb70d94b964a3cb7d225983368bc25bebe01e995293dcc2
command: [ "server", "--address", ":9000" ]
environment:
RUSTFS_ADDRESS: ":9000"
RUSTFS_VOLUMES: "/data"
RUSTFS_REGION: "${S3_REGION:-us-east-1}"
# RustFS принимает root-учётные данные при инициализации
RUSTFS_ROOT_USER: "${S3_ROOT_USER}"
RUSTFS_ROOT_PASSWORD: "${S3_ROOT_PASSWORD}"
RUSTFS_CONSOLE_ENABLE: "false"
volumes:
- s3_data:/data
restart: unless-stopped
s3-init:
image: docker.io/minio/mc:latest # Или тот образ, который у тебя успешно тянется
depends_on:
s3:
condition: service_started
environment:
S3_ENDPOINT: "${S3_ENDPOINT:-http://s3:9000}"
S3_BUCKET: "${S3_BUCKET:-messenger-attachments}"
# Скрипт использует root-ключи для создания bucket и ограничения прав API-пользователя
S3_ROOT_USER: "${S3_ROOT_USER}"
S3_ROOT_PASSWORD: "${S3_ROOT_PASSWORD}"
S3_API_ACCESS_KEY_ID: "${S3_ACCESS_KEY_ID}"
S3_API_SECRET_ACCESS_KEY: "${S3_SECRET_ACCESS_KEY}"
volumes:
- ./infra/rustfs-bootstrap.sh:/bootstrap.sh:ro
entrypoint: [ "/bin/sh", "/bootstrap.sh" ]
restart: "no"
volumes:
postgres_data:
redis_data:
s3_data:
+31
View File
@@ -0,0 +1,31 @@
module mtusi2026lab4-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/minio/minio-go/v7 v7.0.70
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/dustin/go-humanize v1.0.1 // indirect
github.com/goccy/go-json v0.10.2 // 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
github.com/klauspost/compress v1.17.6 // indirect
github.com/klauspost/cpuid/v2 v2.2.6 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/rs/xid v1.5.0 // indirect
golang.org/x/net v0.23.0 // indirect
golang.org/x/sync v0.1.0 // indirect
golang.org/x/sys v0.18.0 // indirect
golang.org/x/text v0.14.0 // indirect
gopkg.in/ini.v1 v1.67.0 // indirect
)
+64
View File
@@ -0,0 +1,64 @@
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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
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/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
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/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v7 v7.0.70 h1:1u9NtMgfK1U42kUxcsl5v0yj6TEOPR497OAQxpJnn2g=
github.com/minio/minio-go/v7 v7.0.70/go.mod h1:4yBA8v80xGA30cfM3fz0DKYMXunWl/AV/6tWEs9ryzo=
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/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
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/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
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/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
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
+74
View File
@@ -0,0 +1,74 @@
#!/bin/sh
set -eu
export AWS_EC2_METADATA_DISABLED=true
: "${S3_ENDPOINT:?S3_ENDPOINT is required}"
: "${S3_BUCKET:?S3_BUCKET is required}"
: "${AWS_DEFAULT_REGION:?AWS_DEFAULT_REGION is required}"
echo "Waiting for RustFS S3 API at ${S3_ENDPOINT} ..."
i=0
while true; do
i=$((i + 1))
if aws --endpoint-url "${S3_ENDPOINT}" s3api list-buckets --region "${AWS_DEFAULT_REGION}" >/dev/null 2>&1; then
echo "RustFS is reachable."
break
fi
if [ "$i" -ge 60 ]; then
echo "RustFS did not become reachable in time" >&2
exit 1
fi
sleep 2
done
echo "Ensuring bucket ${S3_BUCKET} ..."
out=$(aws \
--endpoint-url "${S3_ENDPOINT}" \
s3api create-bucket \
--bucket "${S3_BUCKET}" \
--region "${AWS_DEFAULT_REGION}" 2>&1) || true
case "${out}" in
*BucketAlreadyOwnedByYou*|*BucketAlreadyExists*|*already exists*)
echo "Bucket already exists."
;;
*AccessDenied*)
echo "Cannot create bucket: access denied." >&2
echo "${out}" >&2
exit 1
;;
*error*|*Error*)
echo "Unexpected create-bucket output:" >&2
echo "${out}" >&2
exit 1
;;
*)
echo "Bucket created or already present."
;;
esac
echo "Verifying bucket ..."
aws --endpoint-url "${S3_ENDPOINT}" s3api head-bucket --bucket "${S3_BUCKET}" --region "${AWS_DEFAULT_REGION}" >/dev/null
echo "Making bucket private (best effort) ..."
aws --endpoint-url "${S3_ENDPOINT}" \
s3api put-bucket-acl \
--bucket "${S3_BUCKET}" \
--acl private \
--region "${AWS_DEFAULT_REGION}" >/dev/null 2>&1 || true
aws --endpoint-url "${S3_ENDPOINT}" \
s3api put-public-access-block \
--bucket "${S3_BUCKET}" \
--public-access-block-configuration \
BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true \
--region "${AWS_DEFAULT_REGION}" >/dev/null 2>&1 || true
echo "RustFS bootstrap completed"
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
echo "Restarting stateful services and API without removing volumes ..."
docker compose --env-file .env restart postgres redis s3 api lb
echo "waiting for readiness ..."
i=0
while true; do
i=$((i + 1))
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then
echo "ready"
exit 0
fi
if [ "$i" -ge 90 ]; then
echo "API did not become ready in time" >&2
exit 1
fi
sleep 1
done
+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
+232
View File
@@ -0,0 +1,232 @@
package main
import (
"context"
"log"
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
"mtusi2026lab4-fork/src/internal/handler"
"mtusi2026lab4-fork/src/internal/session"
"mtusi2026lab4-fork/src/internal/storage"
"mtusi2026lab4-fork/src/internal/store"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/google/uuid"
)
// instanceID — уникальный идентификатор реплики.
// Источник — hostname контейнера Docker, поэтому две реплики всегда дают разные значения.
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))
})
}
// InstanceIDMiddleware добавляет X-Instance-Id во все ответы.
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://lab4:lab4@postgres:5432/lab4?sslmode=disable&timezone=UTC"
}
log.Printf("INFO: [%s] connecting to PostgreSQL...", instanceID)
pgStore, err := store.NewPostgres(dbURL)
if err != nil {
log.Fatalf("ERROR: [%s] failed to connect to database: %v", instanceID, 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: [%s] failed to connect to Redis: %v", instanceID, err)
}
defer redisStore.Close()
log.Printf("INFO: [%s] Redis connected", instanceID)
s3Cfg := storage.ConfigFromEnv()
log.Printf("INFO: [%s] connecting to S3 endpoint=%s bucket=%s...", instanceID, s3Cfg.Endpoint, s3Cfg.Bucket)
s3Client, err := storage.NewClient(s3Cfg)
if err != nil {
log.Fatalf("ERROR: [%s] failed to connect to S3: %v", instanceID, err)
}
log.Printf("INFO: [%s] S3 connected", instanceID)
h := handler.New(pgStore, redisStore, s3Client, sessionTTL)
reconcilerCtx, reconcilerCancel := context.WithCancel(context.Background())
defer reconcilerCancel()
go runAttachmentReconciler(reconcilerCtx, pgStore, s3Client, s3Cfg.Grace)
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)
// Лабораторная 4: вложения.
r.Post("/chats/{chat_id}/attachments", h.UploadAttachment)
r.Get("/attachments/{attachment_id}", h.GetAttachment)
r.Get("/attachments/{attachment_id}/content", h.DownloadAttachment)
})
})
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,
ReadHeaderTimeout: 10 * time.Second,
// Для лабы 4 нужны загрузки до 10 MiB, поэтому read/write timeout увеличены.
ReadTimeout: 60 * time.Second,
WriteTimeout: 60 * time.Second,
IdleTimeout: 120 * 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)
// Останавливаем reconciler, чтобы он не работал во время shutdown.
reconcilerCancel()
ctx, cancel := context.WithTimeout(context.Background(), 8*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)
}
func runAttachmentReconciler(ctx context.Context, st store.Store, cl *storage.Client, grace time.Duration) {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
log.Printf("INFO: [%s] attachment reconciler started, grace=%v", instanceID, grace)
for {
select {
case <-ctx.Done():
log.Printf("INFO: [%s] attachment reconciler stopped", instanceID)
return
case <-ticker.C:
cutoff := time.Now().Add(-grace)
items, err := st.ClaimStaleUploading(ctx, cutoff)
if err != nil {
log.Printf("ERROR: [%s] reconciler claim stale uploading: %v", instanceID, err)
continue
}
if len(items) == 0 {
continue
}
log.Printf("INFO: [%s] reconciler found %d stale uploading attachments", instanceID, len(items))
for _, a := range items {
if err := cl.DeleteObject(ctx, a.ObjectKey); err != nil {
log.Printf("ERROR: [%s] reconciler delete object %s: %v", instanceID, a.ObjectKey, err)
continue
}
if err := st.DeleteFailedStaleAttachment(ctx, a.ID); err != nil {
log.Printf("ERROR: [%s] reconciler delete stale attachment row %s: %v", instanceID, a.ID, err)
continue
}
log.Printf("INFO: [%s] reconciler cleaned stale attachment %s object=%s", instanceID, a.ID, a.ObjectKey)
}
}
}
}
+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)
}
+881
View File
@@ -0,0 +1,881 @@
package handler
import (
"bytes"
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"log"
"net/http"
"regexp"
"strconv"
"strings"
"time"
"unicode"
"unicode/utf8"
"mtusi2026lab4-fork/src/internal/auth"
"mtusi2026lab4-fork/src/internal/model"
"mtusi2026lab4-fork/src/internal/storage"
"mtusi2026lab4-fork/src/internal/store"
"github.com/go-chi/chi/v5"
"github.com/google/uuid"
)
type CtxKey string
const RequestIDKey CtxKey = "request_id"
const UserIDKey CtxKey = "user_id"
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
var pngSignature = []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
var (
errUnsupportedImage = errors.New("unsupported_image")
errCorruptImage = errors.New("corrupt_image")
)
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
s3 *storage.Client
sessionTTL time.Duration
}
func New(s store.Store, ss SessionStore, s3 *storage.Client, ttl time.Duration) *Handler {
return &Handler{
store: s,
sessionStore: ss,
s3: s3,
sessionTTL: ttl,
}
}
func isValidUUID(s string) bool {
_, err := uuid.Parse(s)
return err == nil
}
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.RFC3339Nano), // Nano для корректной пагинации
}
}
func chatToMap(c *model.Chat) map[string]interface{} {
ids := c.MemberIDs
if ids == nil {
ids = []string{}
}
return map[string]interface{}{
"id": c.ID,
"title": c.Title,
"member_ids": ids,
"created_at": c.CreatedAt.UTC().Format(time.RFC3339Nano), // Nano для корректной пагинации
}
}
func messageToMap(m *model.Message) map[string]interface{} {
ids := m.AttachmentIDs
if ids == nil {
ids = []string{}
}
return map[string]interface{}{
"id": m.ID,
"chat_id": m.ChatID,
"sender_id": m.SenderID,
"text": m.Text,
"attachment_ids": ids,
"created_at": m.CreatedAt.UTC().Format(time.RFC3339Nano), // Nano для корректной пагинации
}
}
func attachmentToMap(a *model.Attachment) map[string]interface{} {
variants := []any{}
if a.Variants != nil {
variants = a.Variants
}
var errorCode interface{} = nil
if a.ErrorCode != nil {
errorCode = *a.ErrorCode
}
return map[string]interface{}{
"id": a.ID,
"chat_id": a.ChatID,
"owner_id": a.OwnerID,
"filename": a.Filename,
"content_type": a.ContentType,
"size_bytes": a.SizeBytes,
"sha256": a.SHA256,
"status": a.Status,
"variants": variants,
"error_code": errorCode,
"created_at": a.CreatedAt.UTC().Format(time.RFC3339Nano), // Nano
"updated_at": a.UpdatedAt.UTC().Format(time.RFC3339Nano), // Nano
}
}
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 validateFilename(name string) bool {
if name == "" || utf8.RuneCountInString(name) > 255 {
return false
}
for _, ch := range name {
if ch == '/' || ch == '\\' || ch == 0 || unicode.IsControl(ch) {
return false
}
}
return true
}
func detectImage(data []byte) (string, image.Config, error) {
if len(data) == 0 {
return "", image.Config{}, errUnsupportedImage
}
if bytes.HasPrefix(data, pngSignature) {
cfg, _, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil || cfg.Width <= 0 || cfg.Height <= 0 {
return "", image.Config{}, errCorruptImage
}
return "image/png", cfg, nil
}
if len(data) >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF {
cfg, _, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil || cfg.Width <= 0 || cfg.Height <= 0 {
return "", image.Config{}, errCorruptImage
}
return "image/jpeg", cfg, nil
}
return "", image.Config{}, errUnsupportedImage
}
func sha256Hex(b []byte) string {
sum := sha256.Sum256(b)
return hex.EncodeToString(sum[:])
}
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 !usernamePattern.MatchString(req.Username) || utf8.RuneCountInString(req.Password) < 12 || utf8.RuneCountInString(req.Password) > 128 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
pwHash, err := auth.HashPassword(req.Password)
if err != nil {
log.Printf("ERROR: hash password: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
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 {
log.Printf("ERROR: generate token: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
tokenHash := auth.HashToken(token)
expiresAt := time.Now().Add(h.sessionTTL)
if _, err := h.store.CreateSession(r.Context(), user.ID, tokenHash, expiresAt); err != nil {
log.Printf("ERROR: create postgres session: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
if err := h.sessionStore.Set(r.Context(), user.ID, tokenHash, h.sessionTTL); err != nil {
_ = h.store.DeleteSession(r.Context(), tokenHash)
log.Printf("ERROR: create redis session: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
respondJSON(w, http.StatusCreated, map[string]interface{}{
"token": token,
"token_type": "Bearer",
"expires_at": expiresAt.UTC().Format(time.RFC3339Nano),
"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 {
log.Printf("ERROR: delete postgres session: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
if err := h.sessionStore.Delete(r.Context(), tokenHash); err != nil {
log.Printf("WARN: delete redis session: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
}
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
}
token := strings.TrimPrefix(authHeader, "Bearer ")
tokenHash := auth.HashToken(token)
userID, err := h.sessionStore.Get(r.Context(), tokenHash)
if err != nil {
sess, errPg := h.store.GetSession(r.Context(), tokenHash)
if errPg != nil {
if errors.Is(errPg, store.ErrNotFound) {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
log.Printf("ERROR: postgres session lookup: %v [request_id=%s]", errPg, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
if 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 || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
user, err := h.store.GetUserByID(r.Context(), userID)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
log.Printf("ERROR: get user by id: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
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 || !isValidUUID(userID) {
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
}
if len(req.MemberIDs) == 0 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
seen := make(map[string]struct{}, len(req.MemberIDs))
isMember := false
for _, id := range req.MemberIDs {
if !isValidUUID(id) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if _, exists := seen[id]; exists {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
seen[id] = struct{}{}
if id == userID {
isMember = true
}
if _, err := h.store.GetUserByID(r.Context(), id); err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusNotFound, "not_found")
return
}
log.Printf("ERROR: validate chat member: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
}
if !isMember {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
chat, err := h.store.CreateChat(r.Context(), req.Title, req.MemberIDs)
if err != nil {
switch {
case errors.Is(err, store.ErrInvalidRequest), errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusBadRequest, "invalid_request")
case errors.Is(err, store.ErrConflict):
respondError(w, r, http.StatusConflict, "conflict")
default:
log.Printf("ERROR: create chat: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
respondJSON(w, http.StatusCreated, chatToMap(chat))
}
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
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 {
switch {
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
default:
log.Printf("ERROR: list chats: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
items := make([]map[string]interface{}, 0, len(chats))
for _, c := range chats {
items = append(items, chatToMap(c))
}
respondJSON(w, http.StatusOK, map[string]interface{}{
"items": items,
"next_cursor": nextCursor,
})
}
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
chatID := chi.URLParam(r, "chat_id")
if !isValidUUID(chatID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
chat, err := h.store.GetChat(r.Context(), chatID, userID)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusNotFound, "not_found")
return
}
log.Printf("ERROR: get chat: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
respondJSON(w, http.StatusOK, chatToMap(chat))
}
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 || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
chatID := chi.URLParam(r, "chat_id")
if !isValidUUID(chatID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
idemKey := r.Header.Get("Idempotency-Key")
if !idempotencyKeyPattern.MatchString(idemKey) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
var req struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&req); err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if req.AttachmentIDs == nil {
req.AttachmentIDs = []string{}
}
if utf8.RuneCountInString(req.Text) > 4000 || len(req.AttachmentIDs) > 10 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if strings.TrimSpace(req.Text) == "" && len(req.AttachmentIDs) == 0 {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
seen := make(map[string]struct{}, len(req.AttachmentIDs))
normalized := make([]string, 0, len(req.AttachmentIDs))
for _, rawID := range req.AttachmentIDs {
parsed, err := uuid.Parse(rawID)
if err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
id := parsed.String()
if _, exists := seen[id]; exists {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
seen[id] = struct{}{}
normalized = append(normalized, id)
}
req.AttachmentIDs = normalized
canonicalBody, err := json.Marshal(struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}{
Text: req.Text,
AttachmentIDs: req.AttachmentIDs,
})
if err != nil {
log.Printf("ERROR: marshal canonical message: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
requestHash := sha256Hex(canonicalBody)
path := "/api/v1/chats/" + chatID + "/messages"
msg, err := h.store.SendMessageIdempotent(
r.Context(),
chatID,
userID,
req.Text,
req.AttachmentIDs,
idemKey,
path,
requestHash,
)
if err != nil {
switch {
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
case errors.Is(err, store.ErrConflict):
respondError(w, r, http.StatusConflict, "conflict")
default:
log.Printf("ERROR: send message: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
if msg.AttachmentIDs == nil {
msg.AttachmentIDs = []string{}
}
respondJSON(w, http.StatusCreated, messageToMap(msg))
}
func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
chatID := chi.URLParam(r, "chat_id")
if !isValidUUID(chatID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
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(), chatID, userID, r.URL.Query().Get("cursor"), limit)
if err != nil {
switch {
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
default:
log.Printf("ERROR: get messages: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
items := make([]map[string]interface{}, 0, len(messages))
for _, m := range messages {
if m.AttachmentIDs == nil {
m.AttachmentIDs = []string{}
}
items = append(items, messageToMap(m))
}
respondJSON(w, http.StatusOK, map[string]interface{}{
"items": items,
"next_cursor": nextCursor,
})
}
func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
if h.s3 == nil {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
chatID := chi.URLParam(r, "chat_id")
if !isValidUUID(chatID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
filename := r.URL.Query().Get("filename")
if !validateFilename(filename) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if _, err := h.store.GetChat(r.Context(), chatID, userID); err != nil {
if errors.Is(err, store.ErrNotFound) {
respondError(w, r, http.StatusNotFound, "not_found")
return
}
log.Printf("ERROR: chat membership for upload: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
cfg := h.s3.Config()
data, err := io.ReadAll(io.LimitReader(r.Body, cfg.MaxUpload+1))
if err != nil {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
if int64(len(data)) > cfg.MaxUpload {
respondError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large")
return
}
contentType, imgCfg, err := detectImage(data)
if err != nil {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
reqContentType := r.Header.Get("Content-Type")
if reqContentType != "" && !strings.HasPrefix(reqContentType, contentType) {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
pixels := int64(imgCfg.Width) * int64(imgCfg.Height)
if pixels > cfg.MaxPixels {
respondError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large")
return
}
if _, _, err := image.Decode(bytes.NewReader(data)); err != nil {
respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type")
return
}
sum := sha256.Sum256(data)
sha := hex.EncodeToString(sum[:])
existingInChat, err := h.store.GetAttachmentBySHA256InChat(r.Context(), chatID, sha)
if err == nil && existingInChat != nil {
log.Printf("INFO: dedup hit (same chat): sha256=%s chat_id=%s attachment_id=%s [request_id=%s]",
sha[:16], chatID, existingInChat.ID, r.Context().Value(RequestIDKey))
respondJSON(w, http.StatusOK, attachmentToMap(existingInChat))
return
}
existingAnywhere, err := h.store.GetReadyAttachmentBySHA256(r.Context(), sha)
if err == nil && existingAnywhere != nil {
log.Printf("INFO: dedup hit (reuse S3 object): sha256=%s from_chat=%s to_chat=%s [request_id=%s]",
sha[:16], existingAnywhere.ChatID, chatID, r.Context().Value(RequestIDKey))
newAtt, err := h.store.CreateAttachmentReady(
r.Context(),
chatID, userID, filename,
existingAnywhere.ObjectKey,
existingAnywhere.ContentType,
int64(len(data)),
sha,
)
if err != nil {
log.Printf("ERROR: create attachment ready (dedup): %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
respondJSON(w, http.StatusCreated, attachmentToMap(newAtt))
return
}
ext := ".png"
if contentType == "image/jpeg" {
ext = ".jpeg"
}
objectKey := uuid.NewString() + ext
att, err := h.store.CreateAttachmentUploading(
r.Context(), chatID, userID, filename, objectKey, contentType, int64(len(data)), sha,
)
if err != nil {
switch {
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
case errors.Is(err, store.ErrConflict):
respondError(w, r, http.StatusConflict, "conflict")
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
default:
log.Printf("ERROR: create attachment uploading: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
if err := h.s3.PutObject(r.Context(), objectKey, data, contentType); err != nil {
_ = h.store.DeleteAttachmentUploading(r.Context(), att.ID)
if errors.Is(err, storage.ErrDependencyUnavailable) {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
log.Printf("ERROR: s3 put object: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
return
}
ready, err := h.store.MarkAttachmentReady(r.Context(), att.ID)
if err != nil {
log.Printf("ERROR: mark attachment ready: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
respondJSON(w, http.StatusCreated, attachmentToMap(ready))
}
func (h *Handler) GetAttachment(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
attachmentID := chi.URLParam(r, "attachment_id")
if !isValidUUID(attachmentID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
att, err := h.store.GetAttachmentForUser(r.Context(), attachmentID, userID)
if err != nil {
switch {
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
default:
log.Printf("ERROR: get attachment: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
respondJSON(w, http.StatusOK, attachmentToMap(att))
}
func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) {
userID, ok := r.Context().Value(UserIDKey).(string)
if !ok || !isValidUUID(userID) {
respondError(w, r, http.StatusUnauthorized, "unauthorized")
return
}
if h.s3 == nil {
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
return
}
attachmentID := chi.URLParam(r, "attachment_id")
if !isValidUUID(attachmentID) {
respondError(w, r, http.StatusBadRequest, "invalid_request")
return
}
att, err := h.store.GetAttachmentForUser(r.Context(), attachmentID, userID)
if err != nil {
switch {
case errors.Is(err, store.ErrNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
case errors.Is(err, store.ErrInvalidRequest):
respondError(w, r, http.StatusBadRequest, "invalid_request")
default:
log.Printf("ERROR: get attachment for download: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
if att.Status != "ready" {
respondError(w, r, http.StatusNotFound, "not_found")
return
}
obj, err := h.s3.GetObject(r.Context(), att.ObjectKey)
if err != nil {
switch {
case errors.Is(err, storage.ErrObjectNotFound):
respondError(w, r, http.StatusNotFound, "not_found")
case errors.Is(err, storage.ErrDependencyUnavailable):
respondError(w, r, http.StatusServiceUnavailable, "unavailable")
default:
log.Printf("ERROR: s3 get object: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
respondError(w, r, http.StatusInternalServerError, "internal_error")
}
return
}
defer obj.Body.Close()
w.Header().Set("Content-Type", att.ContentType)
w.Header().Set("Content-Length", strconv.FormatInt(att.SizeBytes, 10))
w.WriteHeader(http.StatusOK)
if _, err := io.Copy(w, obj.Body); err != nil {
log.Printf("ERROR: copy attachment body: %v [request_id=%s]", err, r.Context().Value(RequestIDKey))
}
}
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"})
}
+51
View File
@@ -0,0 +1,51 @@
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"`
AttachmentIDs []string `json:"attachment_ids"`
CreatedAt time.Time `json:"created_at"`
}
type Session struct {
ID string `json:"-"`
UserID string `json:"-"`
TokenHash string `json:"-"`
ExpiresAt time.Time `json:"expires_at"`
CreatedAt time.Time `json:"created_at"`
}
type Attachment struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
OwnerID string `json:"owner_id"`
Filename string `json:"filename"`
ObjectKey string `json:"-"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
Status string `json:"status"`
Variants []any `json:"variants"`
ErrorCode *string `json:"error_code"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_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
}
+230
View File
@@ -0,0 +1,230 @@
package storage
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log"
"net/url"
"os"
"strconv"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
var (
ErrDependencyUnavailable = errors.New("s3_unavailable")
ErrObjectNotFound = errors.New("object_not_found")
)
type Config struct {
Endpoint string
Region string
Bucket string
AccessKey string
SecretKey string
UseSSL bool
MaxUpload int64
MaxPixels int64
Grace time.Duration
}
type Client struct {
client *minio.Client
bucket string
cfg Config
}
func ConfigFromEnv() Config {
endpoint := getenv("S3_ENDPOINT", "http://s3:9000")
region := getenv("S3_REGION", "us-east-1")
bucket := getenv("S3_BUCKET", "messenger-attachments")
access := getenv("S3_ACCESS_KEY_ID", "")
secret := getenv("S3_SECRET_ACCESS_KEY", "")
useSSL := false
if v := getenv("S3_USE_SSL", "false"); v != "" {
parsed, err := strconv.ParseBool(v)
if err == nil {
useSSL = parsed
}
}
if strings.HasPrefix(endpoint, "http://") || strings.HasPrefix(endpoint, "https://") {
u, err := url.Parse(endpoint)
if err == nil {
endpoint = u.Host
if u.Scheme == "https" {
useSSL = true
}
}
}
maxUpload := getInt64("MAX_UPLOAD_BYTES", 10*1024*1024)
maxPixels := getInt64("MAX_IMAGE_PIXELS", 40_000_000)
grace := time.Duration(getInt64("ATTACHMENT_GRACE_SECONDS", 600)) * time.Second
return Config{
Endpoint: endpoint,
Region: region,
Bucket: bucket,
AccessKey: access,
SecretKey: secret,
UseSSL: useSSL,
MaxUpload: maxUpload,
MaxPixels: maxPixels,
Grace: grace,
}
}
func NewClient(cfg Config) (*Client, error) {
if cfg.Endpoint == "" {
return nil, errors.New("S3_ENDPOINT is required")
}
if cfg.Bucket == "" {
return nil, errors.New("S3_BUCKET is required")
}
if cfg.AccessKey == "" || cfg.SecretKey == "" {
return nil, errors.New("S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY are required")
}
client, err := minio.New(cfg.Endpoint, &minio.Options{
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
Secure: cfg.UseSSL,
Region: cfg.Region,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
return nil, fmt.Errorf("create minio client: %w", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
exists, err := client.BucketExists(ctx, cfg.Bucket)
if err != nil {
return nil, fmt.Errorf("check bucket exists: %w", err)
}
if !exists {
err = client.MakeBucket(ctx, cfg.Bucket, minio.MakeBucketOptions{Region: cfg.Region})
if err != nil {
return nil, fmt.Errorf("create bucket %s: %w", cfg.Bucket, err)
}
log.Printf("INFO: Successfully created bucket '%s'", cfg.Bucket)
}
return &Client{
client: client,
bucket: cfg.Bucket,
cfg: cfg,
}, nil
}
func (c *Client) Config() Config {
return c.cfg
}
func (c *Client) PutObject(ctx context.Context, key string, data []byte, contentType string) error {
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
_, err := c.client.PutObject(
ctx,
c.bucket,
key,
bytes.NewReader(data),
int64(len(data)),
minio.PutObjectOptions{
ContentType: contentType,
},
)
if err != nil {
return fmt.Errorf("%w: put object: %v", ErrDependencyUnavailable, err)
}
return nil
}
type Object struct {
Body io.ReadCloser
Size int64
ContentType string
}
func (c *Client) GetObject(ctx context.Context, key string) (*Object, error) {
// ВАЖНО: не создаём новый контекст с таймаутом и не делаем defer cancel().
// Контекст HTTP-запроса должен жить, пока клиент читает поток (io.Copy).
// Он будет отменён автоматически при отключении клиента.
info, err := c.client.StatObject(ctx, c.bucket, key, minio.StatObjectOptions{})
if err != nil {
errResp := minio.ToErrorResponse(err)
if errResp.StatusCode == 404 || errResp.Code == "NoSuchKey" || errResp.Code == "NotFound" {
return nil, ErrObjectNotFound
}
return nil, fmt.Errorf("%w: stat object: %v", ErrDependencyUnavailable, err)
}
obj, err := c.client.GetObject(ctx, c.bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, fmt.Errorf("%w: get object: %v", ErrDependencyUnavailable, err)
}
contentType := info.ContentType
if contentType == "" {
contentType = "application/octet-stream"
}
return &Object{
Body: obj,
Size: info.Size,
ContentType: contentType,
}, nil
}
func (c *Client) DeleteObject(ctx context.Context, key string) error {
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
err := c.client.RemoveObject(ctx, c.bucket, key, minio.RemoveObjectOptions{})
if err != nil {
errResp := minio.ToErrorResponse(err)
if errResp.StatusCode == 404 ||
errResp.Code == "NoSuchKey" ||
errResp.Code == "NotFound" {
return nil
}
return fmt.Errorf("%w: delete object: %v", ErrDependencyUnavailable, err)
}
return nil
}
func getenv(key, fallback string) string {
if v := os.Getenv(key); v != "" {
return v
}
return fallback
}
func getInt64(key string, fallback int64) int64 {
v := os.Getenv(key)
if v == "" {
return fallback
}
parsed, err := strconv.ParseInt(v, 10, 64)
if err != nil || parsed <= 0 {
return fallback
}
return parsed
}
@@ -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;
@@ -0,0 +1,27 @@
CREATE TABLE IF NOT EXISTS attachments (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
filename TEXT NOT NULL,
object_key TEXT NOT NULL UNIQUE,
content_type TEXT NOT NULL,
size_bytes BIGINT NOT NULL,
sha256 CHAR(64) NOT NULL,
status TEXT NOT NULL DEFAULT 'ready'
CHECK (status IN ('uploading', 'ready', 'failed')),
error_code TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_attachments_chat_id ON attachments (chat_id);
CREATE INDEX IF NOT EXISTS idx_attachments_status_created_at ON attachments (status, created_at);
CREATE TABLE IF NOT EXISTS message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
position INT NOT NULL,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX IF NOT EXISTS idx_message_attachments_message_id ON message_attachments (message_id, position);
@@ -0,0 +1,3 @@
-- Лабораторная 4: разрешаем пустой текст, если есть вложения.
-- Валидация "непустой текст ИЛИ непустой attachment_ids" выполняется на уровне приложения (handler.go).
ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_check;
+841
View File
@@ -0,0 +1,841 @@
package store
import (
"context"
"crypto/sha256"
"embed"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"log"
"strings"
"time"
"unicode/utf8"
"mtusi2026lab4-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")
)
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 string, attachmentIDs []string, 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
CreateAttachmentUploading(ctx context.Context, chatID, ownerID, filename, objectKey, contentType string, sizeBytes int64, sha256Hex string) (*model.Attachment, error)
MarkAttachmentReady(ctx context.Context, id string) (*model.Attachment, error)
DeleteAttachmentUploading(ctx context.Context, id string) error
GetAttachmentForUser(ctx context.Context, attachmentID, userID string) (*model.Attachment, error)
ClaimStaleUploading(ctx context.Context, olderThan time.Time) ([]model.Attachment, error)
DeleteFailedStaleAttachment(ctx context.Context, id string) error
GetReadyAttachmentBySHA256(ctx context.Context, sha256Hex string) (*model.Attachment, error)
GetAttachmentBySHA256InChat(ctx context.Context, chatID, sha256Hex string) (*model.Attachment, error)
CreateAttachmentReady(ctx context.Context, chatID, ownerID, filename, objectKey, contentType string, sizeBytes int64, sha256Hex string) (*model.Attachment, 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()
}
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
err := s.pool.QueryRow(ctx, `INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING id, username, display_name, created_at`, 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
err := s.pool.QueryRow(ctx, `SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1`, 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
err := s.pool.QueryRow(ctx, `SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`, 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
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 {
// Используем подзапрос для точного сравнения кортежей без участия Go
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) > (
SELECT c2.created_at, c2.id FROM chats c2 WHERE c2.id = $2
)
ORDER BY c.created_at, c.id
LIMIT $3
`
args = []interface{}{userID, 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 string, attachmentIDs []string, idemKey, path, requestHash string) (*model.Message, error) {
if attachmentIDs == nil {
attachmentIDs = []string{}
}
if len(attachmentIDs) > 10 {
return nil, ErrInvalidRequest
}
if utf8.RuneCountInString(text) > 4000 {
return nil, ErrInvalidRequest
}
if strings.TrimSpace(text) == "" && len(attachmentIDs) == 0 {
return nil, ErrInvalidRequest
}
seen := make(map[string]struct{}, len(attachmentIDs))
for _, id := range attachmentIDs {
if _, exists := seen[id]; exists {
return nil, ErrInvalidRequest
}
seen[id] = struct{}{}
}
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 := 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)
}
if msg.AttachmentIDs == nil {
msg.AttachmentIDs = []string{}
}
msg.CreatedAt = msg.CreatedAt.UTC()
return &msg, nil
case errors.Is(err, pgx.ErrNoRows):
for _, attID := range attachmentIDs {
var attChatID string
var status string
qerr := tx.QueryRow(ctx, `SELECT chat_id::text, status FROM attachments WHERE id = $1`, attID).Scan(&attChatID, &status)
if qerr != nil {
if errors.Is(qerr, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if isUUIDSyntaxError(qerr) {
return nil, ErrInvalidRequest
}
return nil, fmt.Errorf("select attachment: %w", qerr)
}
if attChatID != chatID {
return nil, ErrNotFound
}
if status != "ready" {
return nil, ErrConflict
}
}
msg, err := s.insertMessageTx(ctx, tx, chatID, senderID, text)
if err != nil {
return nil, err
}
msg.AttachmentIDs = attachmentIDs
for i, attID := range attachmentIDs {
if _, err := tx.Exec(ctx, `INSERT INTO message_attachments (message_id, attachment_id, position) VALUES ($1, $2, $3)`, msg.ID, attID, i); err != nil {
if isUniqueViolation(err) {
return nil, ErrInvalidRequest
}
return nil, fmt.Errorf("insert message attachment: %w", err)
}
}
body, err := json.Marshal(msg)
if err != nil {
return nil, fmt.Errorf("marshal message: %w", err)
}
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()
msg.AttachmentIDs = []string{}
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()
msg.AttachmentIDs = []string{}
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
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 {
query = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND (created_at, id) > (
SELECT created_at, id FROM messages WHERE id = $2 AND chat_id = $1
)
ORDER BY created_at, id
LIMIT $3
`
args = []interface{}{chatID, 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()
msg.AttachmentIDs = []string{}
messages = append(messages, &msg)
}
var nextCursor *string
if len(messages) > limit {
messages = messages[:limit]
lastID := messages[len(messages)-1].ID
nextCursor = &lastID
}
if messages == nil {
messages = []*model.Message{}
}
if len(messages) > 0 {
ids := make([]string, len(messages))
for i, m := range messages {
ids[i] = m.ID
}
arows, err := s.pool.Query(ctx, `SELECT message_id::text, attachment_id::text FROM message_attachments WHERE message_id = ANY($1::uuid[]) ORDER BY message_id, position`, ids)
if err != nil {
return nil, nil, fmt.Errorf("query message attachments: %w", err)
}
defer arows.Close()
byMessage := make(map[string][]string)
for arows.Next() {
var msgID, attID string
if err := arows.Scan(&msgID, &attID); err != nil {
return nil, nil, fmt.Errorf("scan message attachment: %w", err)
}
byMessage[msgID] = append(byMessage[msgID], attID)
}
if err := arows.Err(); err != nil {
return nil, nil, fmt.Errorf("message attachments rows: %w", err)
}
for _, m := range messages {
if atts, ok := byMessage[m.ID]; ok && len(atts) > 0 {
m.AttachmentIDs = atts
} else {
m.AttachmentIDs = []string{}
}
}
}
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 (s *PostgresStore) CreateAttachmentUploading(ctx context.Context, chatID, ownerID, filename, objectKey, contentType string, sizeBytes int64, sha256Hex string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `INSERT INTO attachments (chat_id, owner_id, filename, object_key, content_type, size_bytes, sha256, status) VALUES ($1, $2, $3, $4, $5, $6, $7, 'uploading') RETURNING id::text, chat_id::text, owner_id::text, filename, object_key, content_type, size_bytes, sha256, status, error_code, created_at, updated_at`, chatID, ownerID, filename, objectKey, contentType, sizeBytes, sha256Hex).
Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt)
if err != nil {
if isUniqueViolation(err) {
return nil, ErrConflict
}
if isForeignKeyViolation(err) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("insert attachment uploading: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
// GetAttachmentByID возвращает метаданные вложения по его ID.
// Используется воркером для получения object_key перед скачиванием из S3.
func (s *PostgresStore) GetAttachmentByID(ctx context.Context, id string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `
SELECT id::text, chat_id::text, owner_id::text, filename, object_key,
content_type, size_bytes, sha256, status, error_code, created_at, updated_at
FROM attachments
WHERE id = $1
`, id).Scan(
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey,
&a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status,
&a.ErrorCode, &a.CreatedAt, &a.UpdatedAt,
)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get attachment by id: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func (s *PostgresStore) MarkAttachmentReady(ctx context.Context, id string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = NOW() WHERE id = $1 AND status = 'uploading' RETURNING id::text, chat_id::text, owner_id::text, filename, object_key, content_type, size_bytes, sha256, status, error_code, created_at, updated_at`, id).
Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("mark attachment ready: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func (s *PostgresStore) DeleteAttachmentUploading(ctx context.Context, id string) error {
_, err := s.pool.Exec(ctx, `DELETE FROM attachments WHERE id = $1 AND status = 'uploading'`, id)
if err != nil {
return fmt.Errorf("delete attachment uploading: %w", err)
}
return nil
}
func (s *PostgresStore) GetAttachmentForUser(ctx context.Context, attachmentID, userID string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `SELECT a.id::text, a.chat_id::text, a.owner_id::text, a.filename, a.object_key, a.content_type, a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at FROM attachments a JOIN chat_members cm ON cm.chat_id = a.chat_id WHERE a.id = $1 AND cm.user_id = $2 AND a.status = 'ready'`, attachmentID, userID).
Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if isUUIDSyntaxError(err) {
return nil, ErrInvalidRequest
}
return nil, fmt.Errorf("get attachment for user: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func (s *PostgresStore) ClaimStaleUploading(ctx context.Context, olderThan time.Time) ([]model.Attachment, error) {
rows, err := s.pool.Query(ctx, `
UPDATE attachments
SET status = 'deleting', error_code = 'stale_cleanup', updated_at = NOW()
WHERE status = 'uploading' AND created_at < $1
RETURNING id::text, object_key
`, olderThan)
if err != nil {
return nil, fmt.Errorf("claim stale uploading: %w", err)
}
defer rows.Close()
var out []model.Attachment
for rows.Next() {
var a model.Attachment
if err := rows.Scan(&a.ID, &a.ObjectKey); err != nil {
return nil, fmt.Errorf("scan claimed attachment: %w", err)
}
out = append(out, a)
}
return out, rows.Err()
}
func (s *PostgresStore) DeleteFailedStaleAttachment(ctx context.Context, id string) error {
_, err := s.pool.Exec(ctx, `
DELETE FROM attachments
WHERE id = $1 AND status = 'deleting'
`, id)
if err != nil {
return fmt.Errorf("delete failed stale attachment: %w", err)
}
return nil
}
func (s *PostgresStore) GetReadyAttachmentBySHA256(ctx context.Context, sha256Hex string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `
SELECT id::text, chat_id::text, owner_id::text, filename, object_key,
content_type, size_bytes, sha256, status, error_code,
created_at, updated_at
FROM attachments
WHERE sha256 = $1 AND status = 'ready'
ORDER BY created_at
LIMIT 1
`, sha256Hex).Scan(
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey,
&a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status,
&a.ErrorCode, &a.CreatedAt, &a.UpdatedAt,
)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get ready attachment by sha256: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func (s *PostgresStore) GetAttachmentBySHA256InChat(ctx context.Context, chatID, sha256Hex string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `
SELECT id::text, chat_id::text, owner_id::text, filename, object_key,
content_type, size_bytes, sha256, status, error_code,
created_at, updated_at
FROM attachments
WHERE chat_id = $1 AND sha256 = $2 AND status = 'ready'
ORDER BY created_at
LIMIT 1
`, chatID, sha256Hex).Scan(
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey,
&a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status,
&a.ErrorCode, &a.CreatedAt, &a.UpdatedAt,
)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("get attachment by sha256 in chat: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func (s *PostgresStore) CreateAttachmentReady(ctx context.Context, chatID, ownerID, filename, objectKey, contentType string, sizeBytes int64, sha256Hex string) (*model.Attachment, error) {
var a model.Attachment
err := s.pool.QueryRow(ctx, `
INSERT INTO attachments (
chat_id, owner_id, filename, object_key,
content_type, size_bytes, sha256, status
)
VALUES ($1, $2, $3, $4, $5, $6, $7, 'ready')
RETURNING id::text, chat_id::text, owner_id::text, filename,
object_key, content_type, size_bytes, sha256,
status, error_code, created_at, updated_at
`, chatID, ownerID, filename, objectKey, contentType, sizeBytes, sha256Hex).Scan(
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey,
&a.ContentType, &a.SizeBytes, &a.SHA256, &a.Status,
&a.ErrorCode, &a.CreatedAt, &a.UpdatedAt,
)
if err != nil {
if isUniqueViolation(err) {
return nil, ErrConflict
}
if isForeignKeyViolation(err) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("insert attachment ready: %w", err)
}
a.CreatedAt = a.CreatedAt.UTC()
a.UpdatedAt = a.UpdatedAt.UTC()
a.Variants = []any{}
return &a, nil
}
func hashScope(s string) int64 {
h := sha256.Sum256([]byte(s))
return int64(binary.BigEndian.Uint64(h[:8]))
}
func isUniqueViolation(err error) bool {
return err != nil && (contains(err.Error(), "23505") || contains(err.Error(), "duplicate key") || contains(err.Error(), "unique constraint"))
}
func isForeignKeyViolation(err error) bool {
return err != nil && (contains(err.Error(), "23503") || contains(err.Error(), "violates foreign key"))
}
func isUUIDSyntaxError(err error) bool {
return err != nil && contains(err.Error(), "invalid input syntax for type uuid")
}
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
}
+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()