From aea79e8ed794c2bbd18c2d5a5fb46ae83b0ebb30 Mon Sep 17 00:00:00 2001 From: Rakshasa2 Date: Mon, 26 Oct 2026 18:16:58 +0300 Subject: [PATCH] =?UTF-8?q?lab4=20-=20=D0=BE=D1=86=D0=B5=D0=BD=D0=BA=D0=B0?= =?UTF-8?q?=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 27 + REPORT.md | 99 ++- docker-compose.yml | 143 +++ infra/haproxy.cfg | 30 + infra/rustfs-bootstrap.sh | 74 ++ scripts/restart.sh | 26 + scripts/stop-one.sh | 31 + src/cmd/server/main.go | 238 +++++ src/internal/auth/auth.go | 46 + src/internal/handler/handler.go | 835 ++++++++++++++++++ src/internal/model/model.go | 51 ++ src/internal/session/redis_store.go | 84 ++ src/internal/storage/s3.go | 230 +++++ src/internal/store/migrations/001_initial.sql | 47 + .../store/migrations/002_idempotency.sql | 19 + .../store/migrations/003_attachments.sql | 27 + .../store/migrations/004_allow_empty_text.sql | 3 + src/internal/store/postgres.go | 718 +++++++++++++++ student-tests/run-test.py | 125 +++ 19 files changed, 2833 insertions(+), 20 deletions(-) create mode 100644 Dockerfile create mode 100644 docker-compose.yml create mode 100644 infra/haproxy.cfg create mode 100755 infra/rustfs-bootstrap.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh create mode 100644 src/cmd/server/main.go create mode 100644 src/internal/auth/auth.go create mode 100644 src/internal/handler/handler.go create mode 100644 src/internal/model/model.go create mode 100644 src/internal/session/redis_store.go create mode 100644 src/internal/storage/s3.go create mode 100644 src/internal/store/migrations/001_initial.sql create mode 100644 src/internal/store/migrations/002_idempotency.sql create mode 100644 src/internal/store/migrations/003_attachments.sql create mode 100644 src/internal/store/migrations/004_allow_empty_text.sql create mode 100644 src/internal/store/postgres.go create mode 100644 student-tests/run-test.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..110588c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +FROM golang:1.22-alpine AS builder + +WORKDIR /build + +COPY go.mod go.sum ./ +RUN go mod download + +COPY src/ ./src/ + +RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/server ./src/cmd/server + +FROM alpine:3.20 + +RUN addgroup -S app && adduser -S -G app app + +WORKDIR /app + +COPY --from=builder /out/server . + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=3 \ + CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health/ready || exit 1 + +CMD ["./server"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index 9ad2b84..90458b0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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:** Эксперименты не доказывают отказоустойчивость к потере всей машины. diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..50daf4e --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,143 @@ +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}" + + # Root/admin credentials (используются Go-кодом для создания bucket) + RUSTFS_ROOT_USER: "${S3_ACCESS_KEY_ID}" + RUSTFS_ROOT_PASSWORD: "${S3_SECRET_ACCESS_KEY}" + + # Console отключена для безопасности + RUSTFS_CONSOLE_ENABLE: "false" + RUSTFS_OBS_LOGGER_LEVEL: "warn" + + volumes: + - s3_data:/data + + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + restart: unless-stopped + +volumes: + postgres_data: + redis_data: + s3_data: \ No newline at end of file diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 0000000..fe761c2 --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,30 @@ +global + log stdout format raw local0 info + maxconn 4096 + +defaults + mode http + timeout connect 5s + timeout client 30s + timeout server 30s + timeout check 5s + option httplog + option dontlognull + +resolvers docker + nameserver dns1 127.0.0.11:53 + hold valid 5s + hold nx 5s + hold refused 5s + hold timeout 5s + +frontend fe_main + bind *:8080 + default_backend be_api + +backend be_api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 2s fall 3 rise 2 init-addr libc,none resolvers docker + server-template api 2 api:8080 check diff --git a/infra/rustfs-bootstrap.sh b/infra/rustfs-bootstrap.sh new file mode 100755 index 0000000..c322479 --- /dev/null +++ b/infra/rustfs-bootstrap.sh @@ -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" \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..9b57d5d --- /dev/null +++ b/scripts/restart.sh @@ -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 \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 0000000..68037e0 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,31 @@ +#!/bin/sh +set -eu + +BASE="${BASE_URL:-http://localhost:8080}" + +RUNNING=$(docker ps --filter "label=com.docker.compose.service=api" --filter "status=running" -q) +COUNT=$(printf '%s\n' "$RUNNING" | grep -c . || true) +if [ "$COUNT" -lt 2 ]; then + echo "need >=2 running api replicas, found $COUNT" >&2 + exit 1 +fi + +TARGET=$(curl -s -D - -o /dev/null "$BASE/health/live" \ + | tr -d '\r' \ + | awk 'tolower($1)=="x-instance-id:"{print $2}') + +if [ -z "$TARGET" ]; then + echo "could not observe X-Instance-Id via LB" >&2 + exit 1 +fi + +if ! printf '%s\n' "$RUNNING" | grep -qi "^${TARGET}"; then + CID=$(docker inspect --format '{{.Id}} {{.Config.Hostname}}' $RUNNING \ + | awk -v t="$TARGET" '$2==t{print substr($1,1,12)}' | head -n 1) + [ -n "$CID" ] || { echo "target $TARGET not a running api replica" >&2; exit 1; } + TARGET="$CID" +fi + +echo "stopping LB-observed replica $TARGET ..." >&2 +docker stop -t 10 "$TARGET" >/dev/null +echo "stopped $TARGET" >&2 diff --git a/src/cmd/server/main.go b/src/cmd/server/main.go new file mode 100644 index 0000000..2a80665 --- /dev/null +++ b/src/cmd/server/main.go @@ -0,0 +1,238 @@ +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) +} + +// runAttachmentReconciler чистит зависшие uploading-вложения. +// +// Это нужно для уровня 4: если процесс умер между S3 PUT и PostgreSQL UPDATE, +// в S3 может остаться объект, а в БД — строка status='uploading'. +// Reconciler спустя grace period помечает такие записи failed, удаляет объект +// из S3 и затем удаляет строку метаданных. +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) + } + } + } +} diff --git a/src/internal/auth/auth.go b/src/internal/auth/auth.go new file mode 100644 index 0000000..57942bb --- /dev/null +++ b/src/internal/auth/auth.go @@ -0,0 +1,46 @@ +package auth + +import ( + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "encoding/base64" + "encoding/hex" + "time" + + "golang.org/x/crypto/bcrypt" +) + +func HashPassword(password string) (string, error) { + hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) + if err != nil { + return "", err + } + return string(hash), nil +} + +func CheckPassword(password, hash string) bool { + err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) + return err == nil +} + +func GenerateToken() (string, error) { + b := make([]byte, 32) + if _, err := rand.Read(b); err != nil { + return "", err + } + return base64.URLEncoding.EncodeToString(b), nil +} + +func HashToken(token string) string { + h := sha256.Sum256([]byte(token)) + return hex.EncodeToString(h[:]) +} + +func SecureCompare(a, b string) bool { + return subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1 +} + +func IsSessionExpired(expiresAt time.Time) bool { + return time.Now().After(expiresAt) +} diff --git a/src/internal/handler/handler.go b/src/internal/handler/handler.go new file mode 100644 index 0000000..06c475c --- /dev/null +++ b/src/internal/handler/handler.go @@ -0,0 +1,835 @@ +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 + } + pixels := int64(imgCfg.Width) * int64(imgCfg.Height) + if pixels > cfg.MaxPixels { + respondError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large") + return + } + + sum := sha256.Sum256(data) + sha := hex.EncodeToString(sum[:]) + 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"}) +} diff --git a/src/internal/model/model.go b/src/internal/model/model.go new file mode 100644 index 0000000..1df2eff --- /dev/null +++ b/src/internal/model/model.go @@ -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"` +} diff --git a/src/internal/session/redis_store.go b/src/internal/session/redis_store.go new file mode 100644 index 0000000..9b7c887 --- /dev/null +++ b/src/internal/session/redis_store.go @@ -0,0 +1,84 @@ +package session + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" +) + +var ( + ErrSessionNotFound = errors.New("session_not_found") + ErrRedisDown = errors.New("redis_unavailable") +) + +// RedisStore реализует handler.SessionStore (Get/Set/Delete). +// Криптография токенов живёт в пакете auth — здесь только хранение. +type RedisStore struct { + client *redis.Client +} + +func NewRedisStore(redisURL string, ttl time.Duration) (*RedisStore, error) { + opts, err := redis.ParseURL(redisURL) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + + opts.DialTimeout = 3 * time.Second + opts.ReadTimeout = 3 * time.Second + opts.WriteTimeout = 3 * time.Second + opts.PoolSize = 20 + opts.MinIdleConns = 5 + + client := redis.NewClient(opts) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("redis ping: %w", err) + } + + return &RedisStore{client: client}, nil +} + +func (s *RedisStore) Close() error { + return s.client.Close() +} + +func (s *RedisStore) Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error { + key := fmt.Sprintf("session:%s", tokenHash) + if err := s.client.Set(ctx, key, userID, ttl).Err(); err != nil { + return fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return nil +} + +func (s *RedisStore) Get(ctx context.Context, tokenHash string) (string, error) { + if tokenHash == "" { + return "", ErrSessionNotFound + } + key := fmt.Sprintf("session:%s", tokenHash) + userID, err := s.client.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return "", ErrSessionNotFound + } + return "", fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return userID, nil +} + +func (s *RedisStore) Delete(ctx context.Context, tokenHash string) error { + key := fmt.Sprintf("session:%s", tokenHash) + if err := s.client.Del(ctx, key).Err(); err != nil { + return fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return nil +} + +func (s *RedisStore) IsAvailable(ctx context.Context) bool { + return s.client.Ping(ctx).Err() == nil +} diff --git a/src/internal/storage/s3.go b/src/internal/storage/s3.go new file mode 100644 index 0000000..e5e73d0 --- /dev/null +++ b/src/internal/storage/s3.go @@ -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 +} diff --git a/src/internal/store/migrations/001_initial.sql b/src/internal/store/migrations/001_initial.sql new file mode 100644 index 0000000..f06a564 --- /dev/null +++ b/src/internal/store/migrations/001_initial.sql @@ -0,0 +1,47 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash VARCHAR(255) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$') + ); + +CREATE INDEX idx_users_username ON users(username); + +CREATE TABLE chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX idx_chat_members_user ON chat_members(user_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_messages_chat_created ON messages(chat_id, created_at, id); + +CREATE TABLE sessions ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + token_hash VARCHAR(64) NOT NULL UNIQUE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_sessions_token ON sessions(token_hash); +CREATE INDEX idx_sessions_user ON sessions(user_id); +CREATE INDEX idx_sessions_expires ON sessions(expires_at); \ No newline at end of file diff --git a/src/internal/store/migrations/002_idempotency.sql b/src/internal/store/migrations/002_idempotency.sql new file mode 100644 index 0000000..2031428 --- /dev/null +++ b/src/internal/store/migrations/002_idempotency.sql @@ -0,0 +1,19 @@ +CREATE TABLE IF NOT EXISTS idempotency_keys ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + method TEXT NOT NULL, + path TEXT NOT NULL, + key TEXT NOT NULL, + request_hash TEXT NOT NULL, -- SHA-256 hex canonical JSON body + response_code INT NOT NULL, + response_body JSONB NOT NULL, -- сохранённый Message для реплея + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + expires_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + INTERVAL '24 hours', + UNIQUE (user_id, method, path, key) + ); + +CREATE INDEX IF NOT EXISTS idx_idem_expires ON idempotency_keys (expires_at); + +-- Сообщения связываем с ключом, чтобы при реплее вернуть тот же объект +ALTER TABLE messages + ADD COLUMN IF NOT EXISTS idempotency_key_id UUID REFERENCES idempotency_keys(id) ON DELETE SET NULL; \ No newline at end of file diff --git a/src/internal/store/migrations/003_attachments.sql b/src/internal/store/migrations/003_attachments.sql new file mode 100644 index 0000000..c8a8d18 --- /dev/null +++ b/src/internal/store/migrations/003_attachments.sql @@ -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); \ No newline at end of file diff --git a/src/internal/store/migrations/004_allow_empty_text.sql b/src/internal/store/migrations/004_allow_empty_text.sql new file mode 100644 index 0000000..aebb4e1 --- /dev/null +++ b/src/internal/store/migrations/004_allow_empty_text.sql @@ -0,0 +1,3 @@ +-- Лабораторная 4: разрешаем пустой текст, если есть вложения. +-- Валидация "непустой текст ИЛИ непустой attachment_ids" выполняется на уровне приложения (handler.go). +ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_check; \ No newline at end of file diff --git a/src/internal/store/postgres.go b/src/internal/store/postgres.go new file mode 100644 index 0000000..417e240 --- /dev/null +++ b/src/internal/store/postgres.go @@ -0,0 +1,718 @@ +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 +} + +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 { + // Используем подзапрос, чтобы избежать потери точности времени при передаче через Go + 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 +} + +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 = 'failed', error_code = 'stale_upload', 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 = 'failed' AND error_code = 'stale_upload'`, id) + if err != nil { + return fmt.Errorf("delete failed stale attachment: %w", err) + } + return 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 +} diff --git a/student-tests/run-test.py b/student-tests/run-test.py new file mode 100644 index 0000000..c8c39f0 --- /dev/null +++ b/student-tests/run-test.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Student tests lab2. Запуск: python3 student-tests/run-test.py [--base-url URL]""" +import argparse +import base64 +import json +import sys +import urllib.error +import urllib.request +import uuid + +BASE = "http://localhost:8080" +FAILURES = [] + +def req(method, path, body=None, raw=None, token=None, ctype="application/json"): + headers, data = {}, None + if raw is not None: + data, headers["Content-Type"] = raw.encode("utf-8"), ctype + elif body is not None: + data, headers["Content-Type"] = json.dumps(body, ensure_ascii=False).encode("utf-8"), ctype + + if token: + if token.startswith("Basic "): + headers["Authorization"] = token + else: + headers["Authorization"] = f"Bearer {token}" + + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=30) as resp: + payload = resp.read().decode("utf-8") + return resp.status, dict(resp.headers), (json.loads(payload) if payload else None) + except urllib.error.HTTPError as e: + payload = e.read().decode("utf-8") + try: + return e.code, dict(e.headers), json.loads(payload) + except ValueError: + return e.code, dict(e.headers), None + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + +def register_user(username, display_name, password): + st, _, body = req("POST", "/api/v1/users", {"username": username, "display_name": display_name, "password": password}) + assert st == 201, f"cannot create user: {st} {body}" + return body + +def login(username, password): + creds = base64.b64encode(f"{username}:{password}".encode()).decode() + st, _, body = req("POST", "/api/v1/auth/sessions", token=f"Basic {creds}") + assert st == 201, f"cannot login: {st} {body}" + return body # Возвращаем весь словарь ответа + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + BASE = ap.parse_args().base_url.rstrip("/") + + # Health checks + st, hdr, body = req("GET", "/health/live") + check("health live 200", st == 200 and body == {"status": "ok"}) + check("X-Request-Id present", bool(hdr.get("X-Request-Id"))) + + # Validation tests + st, _, body = req("POST", "/api/v1/users", raw='{"username": "abc",') + check("malformed JSON -> 400", st == 400 and body["error"]["code"] == "invalid_request") + + st, _, _ = req("POST", "/api/v1/users", {"username": "BadName", "display_name": "x", "password": "validpassword123"}) + check("username pattern -> 400", st == 400) + + # Registration & Login + pwd = "SecurePassword123!" + alice = register_user("alice" + uuid.uuid4().hex[:6], "Алиса", pwd) + bob = register_user("bob" + uuid.uuid4().hex[:6], "Боб", pwd) + + st, _, body = req("POST", "/api/v1/users", {"username": alice["username"], "display_name": "dup", "password": pwd}) + check("duplicate username -> 409", st == 409 and body["error"]["code"] == "conflict") + + # ИСПРАВЛЕНО: Достаем токен из словаря ответа + alice_login_resp = login(alice["username"], pwd) + alice_token = alice_login_resp["token"] + check("login returns token", "token" in alice_login_resp and "user" in alice_login_resp) + + # Auth checks + st, _, body = req("GET", "/api/v1/users/me") + check("no token -> 401", st == 401 and body["error"]["code"] == "unauthorized") + + st, _, body = req("GET", "/api/v1/users/me", token="invalid_token") + check("invalid token -> 401", st == 401) + + # Chat & Messages + st, _, chat = req("POST", "/api/v1/chats", {"title": "Чат", "member_ids": [alice["id"], bob["id"]]}, token=alice_token) + check("create chat 201", st == 201) + + st, _, body = req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "Привет"}, token=alice_token) + check("send message 201", st == 201 and body["text"] == "Привет") + + st, _, body = req("GET", f"/api/v1/chats/{chat['id']}/messages?limit=10", token=alice_token) + check("get messages 200", st == 200 and len(body["items"]) == 1) + + # Outsider check + eve = register_user("eve" + uuid.uuid4().hex[:6], "Ева", pwd) + eve_login_resp = login(eve["username"], pwd) + eve_token = eve_login_resp["token"] # ИСПРАВЛЕНО + + st, _, body = req("GET", f"/api/v1/chats/{chat['id']}", token=eve_token) + check("outsider GET chat -> 404", st == 404 and body["error"]["code"] == "not_found") + + # Logout (Путь согласно openapi.json: /auth/sessions/current) + st, _, _ = req("DELETE", "/api/v1/auth/sessions/current", token=alice_token) + check("logout 204", st == 204) + + st, _, body = req("GET", "/api/v1/users/me", token=alice_token) + check("token revoked -> 401", st == 401) + + print() + if FAILURES: + print(f"FAILED {len(FAILURES)}: {FAILURES}") + sys.exit(1) + print("ALL STUDENT TESTS PASSED") + +if __name__ == "__main__": + main() \ No newline at end of file