lab4 - оценка 4
This commit is contained in:
+27
@@ -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"]
|
||||
@@ -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:** Эксперименты не доказывают отказоустойчивость к потере всей машины.
|
||||
|
||||
@@ -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:
|
||||
@@ -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
|
||||
Executable
+74
@@ -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"
|
||||
Executable
+26
@@ -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
|
||||
Executable
+31
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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"})
|
||||
}
|
||||
@@ -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"`
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package session
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrSessionNotFound = errors.New("session_not_found")
|
||||
ErrRedisDown = errors.New("redis_unavailable")
|
||||
)
|
||||
|
||||
// RedisStore реализует handler.SessionStore (Get/Set/Delete).
|
||||
// Криптография токенов живёт в пакете auth — здесь только хранение.
|
||||
type RedisStore struct {
|
||||
client *redis.Client
|
||||
}
|
||||
|
||||
func NewRedisStore(redisURL string, ttl time.Duration) (*RedisStore, error) {
|
||||
opts, err := redis.ParseURL(redisURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse redis url: %w", err)
|
||||
}
|
||||
|
||||
opts.DialTimeout = 3 * time.Second
|
||||
opts.ReadTimeout = 3 * time.Second
|
||||
opts.WriteTimeout = 3 * time.Second
|
||||
opts.PoolSize = 20
|
||||
opts.MinIdleConns = 5
|
||||
|
||||
client := redis.NewClient(opts)
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
if err := client.Ping(ctx).Err(); err != nil {
|
||||
return nil, fmt.Errorf("redis ping: %w", err)
|
||||
}
|
||||
|
||||
return &RedisStore{client: client}, nil
|
||||
}
|
||||
|
||||
func (s *RedisStore) Close() error {
|
||||
return s.client.Close()
|
||||
}
|
||||
|
||||
func (s *RedisStore) Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error {
|
||||
key := fmt.Sprintf("session:%s", tokenHash)
|
||||
if err := s.client.Set(ctx, key, userID, ttl).Err(); err != nil {
|
||||
return fmt.Errorf("%w: %v", ErrRedisDown, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *RedisStore) Get(ctx context.Context, tokenHash string) (string, error) {
|
||||
if tokenHash == "" {
|
||||
return "", ErrSessionNotFound
|
||||
}
|
||||
key := fmt.Sprintf("session:%s", tokenHash)
|
||||
userID, err := s.client.Get(ctx, key).Result()
|
||||
if err != nil {
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return "", ErrSessionNotFound
|
||||
}
|
||||
return "", fmt.Errorf("%w: %v", ErrRedisDown, err)
|
||||
}
|
||||
return userID, nil
|
||||
}
|
||||
|
||||
func (s *RedisStore) Delete(ctx context.Context, tokenHash string) error {
|
||||
key := fmt.Sprintf("session:%s", tokenHash)
|
||||
if err := s.client.Del(ctx, key).Err(); err != nil {
|
||||
return fmt.Errorf("%w: %v", ErrRedisDown, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *RedisStore) IsAvailable(ctx context.Context) bool {
|
||||
return s.client.Ping(ctx).Err() == nil
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrDependencyUnavailable = errors.New("s3_unavailable")
|
||||
ErrObjectNotFound = errors.New("object_not_found")
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
Endpoint string
|
||||
Region string
|
||||
Bucket string
|
||||
AccessKey string
|
||||
SecretKey string
|
||||
UseSSL bool
|
||||
MaxUpload int64
|
||||
MaxPixels int64
|
||||
Grace time.Duration
|
||||
}
|
||||
|
||||
type Client struct {
|
||||
client *minio.Client
|
||||
bucket string
|
||||
cfg Config
|
||||
}
|
||||
|
||||
func ConfigFromEnv() Config {
|
||||
endpoint := getenv("S3_ENDPOINT", "http://s3:9000")
|
||||
region := getenv("S3_REGION", "us-east-1")
|
||||
bucket := getenv("S3_BUCKET", "messenger-attachments")
|
||||
access := getenv("S3_ACCESS_KEY_ID", "")
|
||||
secret := getenv("S3_SECRET_ACCESS_KEY", "")
|
||||
|
||||
useSSL := false
|
||||
if v := getenv("S3_USE_SSL", "false"); v != "" {
|
||||
parsed, err := strconv.ParseBool(v)
|
||||
if err == nil {
|
||||
useSSL = parsed
|
||||
}
|
||||
}
|
||||
|
||||
if strings.HasPrefix(endpoint, "http://") || strings.HasPrefix(endpoint, "https://") {
|
||||
u, err := url.Parse(endpoint)
|
||||
if err == nil {
|
||||
endpoint = u.Host
|
||||
if u.Scheme == "https" {
|
||||
useSSL = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
maxUpload := getInt64("MAX_UPLOAD_BYTES", 10*1024*1024)
|
||||
maxPixels := getInt64("MAX_IMAGE_PIXELS", 40_000_000)
|
||||
grace := time.Duration(getInt64("ATTACHMENT_GRACE_SECONDS", 600)) * time.Second
|
||||
|
||||
return Config{
|
||||
Endpoint: endpoint,
|
||||
Region: region,
|
||||
Bucket: bucket,
|
||||
AccessKey: access,
|
||||
SecretKey: secret,
|
||||
UseSSL: useSSL,
|
||||
MaxUpload: maxUpload,
|
||||
MaxPixels: maxPixels,
|
||||
Grace: grace,
|
||||
}
|
||||
}
|
||||
|
||||
func NewClient(cfg Config) (*Client, error) {
|
||||
if cfg.Endpoint == "" {
|
||||
return nil, errors.New("S3_ENDPOINT is required")
|
||||
}
|
||||
if cfg.Bucket == "" {
|
||||
return nil, errors.New("S3_BUCKET is required")
|
||||
}
|
||||
if cfg.AccessKey == "" || cfg.SecretKey == "" {
|
||||
return nil, errors.New("S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY are required")
|
||||
}
|
||||
|
||||
client, err := minio.New(cfg.Endpoint, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
|
||||
Secure: cfg.UseSSL,
|
||||
Region: cfg.Region,
|
||||
BucketLookup: minio.BucketLookupPath,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create minio client: %w", err)
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
exists, err := client.BucketExists(ctx, cfg.Bucket)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("check bucket exists: %w", err)
|
||||
}
|
||||
|
||||
if !exists {
|
||||
err = client.MakeBucket(ctx, cfg.Bucket, minio.MakeBucketOptions{Region: cfg.Region})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create bucket %s: %w", cfg.Bucket, err)
|
||||
}
|
||||
log.Printf("INFO: Successfully created bucket '%s'", cfg.Bucket)
|
||||
}
|
||||
|
||||
return &Client{
|
||||
client: client,
|
||||
bucket: cfg.Bucket,
|
||||
cfg: cfg,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (c *Client) Config() Config {
|
||||
return c.cfg
|
||||
}
|
||||
|
||||
func (c *Client) PutObject(ctx context.Context, key string, data []byte, contentType string) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
|
||||
_, err := c.client.PutObject(
|
||||
ctx,
|
||||
c.bucket,
|
||||
key,
|
||||
bytes.NewReader(data),
|
||||
int64(len(data)),
|
||||
minio.PutObjectOptions{
|
||||
ContentType: contentType,
|
||||
},
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("%w: put object: %v", ErrDependencyUnavailable, err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type Object struct {
|
||||
Body io.ReadCloser
|
||||
Size int64
|
||||
ContentType string
|
||||
}
|
||||
|
||||
func (c *Client) GetObject(ctx context.Context, key string) (*Object, error) {
|
||||
// ВАЖНО: не создаём новый контекст с таймаутом и не делаем defer cancel().
|
||||
// Контекст HTTP-запроса должен жить, пока клиент читает поток (io.Copy).
|
||||
// Он будет отменён автоматически при отключении клиента.
|
||||
|
||||
info, err := c.client.StatObject(ctx, c.bucket, key, minio.StatObjectOptions{})
|
||||
if err != nil {
|
||||
errResp := minio.ToErrorResponse(err)
|
||||
if errResp.StatusCode == 404 || errResp.Code == "NoSuchKey" || errResp.Code == "NotFound" {
|
||||
return nil, ErrObjectNotFound
|
||||
}
|
||||
return nil, fmt.Errorf("%w: stat object: %v", ErrDependencyUnavailable, err)
|
||||
}
|
||||
|
||||
obj, err := c.client.GetObject(ctx, c.bucket, key, minio.GetObjectOptions{})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%w: get object: %v", ErrDependencyUnavailable, err)
|
||||
}
|
||||
|
||||
contentType := info.ContentType
|
||||
if contentType == "" {
|
||||
contentType = "application/octet-stream"
|
||||
}
|
||||
|
||||
return &Object{
|
||||
Body: obj,
|
||||
Size: info.Size,
|
||||
ContentType: contentType,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (c *Client) DeleteObject(ctx context.Context, key string) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
err := c.client.RemoveObject(ctx, c.bucket, key, minio.RemoveObjectOptions{})
|
||||
if err != nil {
|
||||
errResp := minio.ToErrorResponse(err)
|
||||
|
||||
if errResp.StatusCode == 404 ||
|
||||
errResp.Code == "NoSuchKey" ||
|
||||
errResp.Code == "NotFound" {
|
||||
return nil
|
||||
}
|
||||
|
||||
return fmt.Errorf("%w: delete object: %v", ErrDependencyUnavailable, err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func getenv(key, fallback string) string {
|
||||
if v := os.Getenv(key); v != "" {
|
||||
return v
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
|
||||
func getInt64(key string, fallback int64) int64 {
|
||||
v := os.Getenv(key)
|
||||
if v == "" {
|
||||
return fallback
|
||||
}
|
||||
|
||||
parsed, err := strconv.ParseInt(v, 10, 64)
|
||||
if err != nil || parsed <= 0 {
|
||||
return fallback
|
||||
}
|
||||
|
||||
return parsed
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
username VARCHAR(32) NOT NULL UNIQUE,
|
||||
display_name VARCHAR(100) NOT NULL,
|
||||
password_hash VARCHAR(255) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
|
||||
CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$')
|
||||
);
|
||||
|
||||
CREATE INDEX idx_users_username ON users(username);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
title VARCHAR(100) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX idx_chat_members_user ON chat_members(user_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE INDEX idx_messages_chat_created ON messages(chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
token_hash VARCHAR(64) NOT NULL UNIQUE,
|
||||
expires_at TIMESTAMPTZ NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE INDEX idx_sessions_token ON sessions(token_hash);
|
||||
CREATE INDEX idx_sessions_user ON sessions(user_id);
|
||||
CREATE INDEX idx_sessions_expires ON sessions(expires_at);
|
||||
@@ -0,0 +1,19 @@
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
method TEXT NOT NULL,
|
||||
path TEXT NOT NULL,
|
||||
key TEXT NOT NULL,
|
||||
request_hash TEXT NOT NULL, -- SHA-256 hex canonical JSON body
|
||||
response_code INT NOT NULL,
|
||||
response_body JSONB NOT NULL, -- сохранённый Message для реплея
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
expires_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + INTERVAL '24 hours',
|
||||
UNIQUE (user_id, method, path, key)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_idem_expires ON idempotency_keys (expires_at);
|
||||
|
||||
-- Сообщения связываем с ключом, чтобы при реплее вернуть тот же объект
|
||||
ALTER TABLE messages
|
||||
ADD COLUMN IF NOT EXISTS idempotency_key_id UUID REFERENCES idempotency_keys(id) ON DELETE SET NULL;
|
||||
@@ -0,0 +1,27 @@
|
||||
CREATE TABLE IF NOT EXISTS attachments (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
filename TEXT NOT NULL,
|
||||
object_key TEXT NOT NULL UNIQUE,
|
||||
content_type TEXT NOT NULL,
|
||||
size_bytes BIGINT NOT NULL,
|
||||
sha256 CHAR(64) NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'ready'
|
||||
CHECK (status IN ('uploading', 'ready', 'failed')),
|
||||
error_code TEXT,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_attachments_chat_id ON attachments (chat_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_attachments_status_created_at ON attachments (status, created_at);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS message_attachments (
|
||||
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
|
||||
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
|
||||
position INT NOT NULL,
|
||||
PRIMARY KEY (message_id, attachment_id)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_message_attachments_message_id ON message_attachments (message_id, position);
|
||||
@@ -0,0 +1,3 @@
|
||||
-- Лабораторная 4: разрешаем пустой текст, если есть вложения.
|
||||
-- Валидация "непустой текст ИЛИ непустой attachment_ids" выполняется на уровне приложения (handler.go).
|
||||
ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_check;
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user