Lab5 - оценка 4 Шиян #40

Open
BVT2304_Shiyan wants to merge 2 commits from BVT2304_Shiyan/mtusi2026lab5:solution/BVT2304-Shiyan into main
56 changed files with 7930 additions and 24 deletions
+10
View File
@@ -18,3 +18,13 @@ __pycache__
node_modules
evidence
.DS_Store
*.pyc
.idea
.vscode
student-tests/
tests/
contracts/
examples/
scripts/
*.md
Dockerfile.example
+24
View File
@@ -0,0 +1,24 @@
# syntax=docker/dockerfile:1
FROM golang:1.26-alpine3.22 AS build
# cgo нужен только для WebP-энкодера (chai2010/webp -> libwebp).
RUN apk add --no-cache build-base libwebp-dev
WORKDIR /src
COPY src/go.mod src/go.sum ./
RUN go mod download
COPY src/ ./
ENV CGO_ENABLED=1
RUN go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server
FROM alpine:3.22 AS runtime
# runtime-библиотека libwebp для динамически слинкованного бинарника.
RUN apk add --no-cache libwebp
RUN addgroup -S app && adduser -S -G app app
WORKDIR /app
COPY --from=build /out/server /app/server
USER app
EXPOSE 8080
ENV APP_HOST=0.0.0.0 APP_PORT=8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O /dev/null http://127.0.0.1:8080/health/live || exit 1
ENTRYPOINT ["/app/server"]
+107 -24
View File
@@ -1,37 +1,120 @@
# Отчёт — лабораторная 5
# Лабораторная 5 — Высоконагруженные приложения: асинхронная обработка вложений
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Автор / группа: BVT2304-Shiyan
Целевая оценка: 4
Трек 5: не заявлен
## Запуск из чистого clone
## 1. Цель и результат
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Лаба 5 развивает лабу 4, отделяя приём файла от тяжёлой обработки: загрузка
возвращает `202 queued` сразу после приёма оригинала и фиксации задания, а
готовность выясняется через последующий `GET` метаданных. Для этого добавлены
отдельный брокер (Redis Streams), отдельный worker-процесс и transactional
outbox для закрытия разрыва между PostgreSQL и брокером.
## Архитектура и решения
Итог: весь уровень 4 реализован:
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- отдельный брокер и worker в Compose;
- durable-сообщения и at-least-once доставка через consumer groups;
- состояния `queued → processing → ready|failed`;
- worker сохраняет оригинал + три варианта (thumbnail/crop/optimized);
- ограниченный retry с backoff и финальный отказ с машинным `error_code`;
- повтор задания не создаёт дубликатов вариантов;
- transactional outbox закрывает разрыв COMMIT → publish;
- аренда/lease защищает от зависшей обработки.
## Доказательства критериев
## 2. Архитектура
Клиент
│
▼
nginx → API × 2 ─────────────────────────┐
│ │
├─► PostgreSQL (метаданные + задания │
│ + outbox + failures) │
│ │
├─► RustFS (staging + финальный prefix) │
│ staging/{chat}/{att} │
│ {chat}/{att}/{original|thumbnail|crop|optimized}
│ │
├─► Redis (кэш + Streams брокер) │
│ Stream: messenger:attachment-jobs │
│ Group: workers │
│ │
└─► Outbox relay (внутри каждой API- │
реплики): читает outbox и публикует │
в поток │
│
┌────────────────────────────────┘
▼
Worker × 1 (consumer group "workers")
├─► XREADGROUP
├─► ClaimJob (lease 60s)
├─► GetObject из staging
├─► buildVariants (thumbnail/crop/optimized)
├─► PutObject каждого варианта и финального оригинала
├─► CompleteJob (транзакцией пишет status=ready, variants, удаляет staging)
└─► XACK только после COMMIT результата
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Реплики stateless. Загрузка через одну реплику — скачивание через другую
подтверждено `X-Instance-Id`.
## Эксперименты и отказы
## 3. Transactional outbox — закрытие разрыва между БД и брокером
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Распределённой транзакции между PostgreSQL и Redis не существует, поэтому
разрыв COMMIT → publish закрывается паттерном outbox:
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
1. Хендлер загрузки в ОДНОЙ транзакции PostgreSQL пишет:
- `attachments` со статусом `queued`
- `jobs` (оркестрационная запись: попытки, lease, backoff)
- `outbox` (намерение опубликовать сообщение)
2. После commit транзакции API отдаёт `202 queued`. Работа **не теряется**
даже при крахе процесса между commit и publish.
3. Отдельная горутина `runOutboxRelay` внутри каждой API-реплики читает
неопубликованные записи из outbox и публикует их в Redis Stream.
4. После успешного `XADD` запись отмечается `published_at`.
## Ограничения и следующие шаги
Повторная публикация безопасна: воркер идемпотентен через claim-гард
(см. раздел 5).
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Доказательство: остановка Redis во время загрузки → задание застревает в
`queued`, не обрабатывается синхронно; после подъёма Redis outbox relay
восстанавливает публикацию и задание доходит до `ready`.
## 4. Жизненный цикл задания
POST /attachments
│
▼ [202 queued]
attachment(status=queued) + job + outbox (одна транзакция)
│
│ relay → Redis Stream
▼
Worker: XREADGROUP → ClaimJob(lease 60s)
│
├─► success → CompleteJob: status=ready, variants=[...], staging удалён
│ XACK
│
├─► permanent error (invalid_image, checksum_mismatch, attachment_missing)
│ FailJob: status=failed, error_code=<machine>, job_failures += 1
│ staging удалён best-effort, XACK
│
└─► transient error (S3 недоступен, сеть)
attempt < max: ScheduleRetry(next_attempt_at = now + backoff), XACK
attempt ≥ max: FailJob(error_code=retry_exhausted), XACK
`next_attempt_at` реально соблюдается: Redis Streams не имеет встроенной
отложенной доставки, поэтому планировщик `EnqueueDueRetries` (каждые 5 c)
публикует новые сообщения только для заданий, у которых срок настал.
## 5. Идемпотентность и защита от зависания
### Claim-гард
`ClaimJob` атомарно переводит `queued → processing` только при выполнении
условия:
```sql
AND (
(status = 'queued' AND (next_attempt_at IS NULL OR next_attempt_at <= now()))
OR (status = 'processing' AND lease_expires_at < now())
)
+202
View File
@@ -0,0 +1,202 @@
services:
postgres:
image: postgres:16-alpine
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD: messenger_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger"]
interval: 5s
timeout: 5s
retries: 5
deploy:
resources:
limits:
cpus: '1.00'
memory: 512M
redis:
image: redis:7-alpine
# LAB 5: брокер должен быть durable — включаем AOF с fsync раз в секунду.
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 5
deploy:
resources:
limits:
cpus: '0.50'
memory: 128M
rustfs:
image: rustfs/rustfs@sha256:ed9210d6411d77ffceb70d94b964a3cb7d225983368bc25bebe01e995293dcc2
environment:
RUSTFS_ACCESS_KEY: ${S3_ACCESS_KEY:-minioadmin}
RUSTFS_SECRET_KEY: ${S3_SECRET_KEY:-minioadmin}
RUSTFS_ADDRESS: 0.0.0.0:9000
RUSTFS_CONSOLE_ADDRESS: 127.0.0.1:9001
RUSTFS_DATA_DIR: /data
MINIO_ROOT_USER: ${S3_ACCESS_KEY:-minioadmin}
MINIO_ROOT_PASSWORD: ${S3_SECRET_KEY:-minioadmin}
volumes:
- rustfs_data:/data
deploy:
resources:
limits:
cpus: '0.50'
memory: 256M
# Однократный сервис миграций: применяется ОДИН РАЗ перед стартом реплик.
migrate:
build:
context: .
dockerfile: Dockerfile
entrypoint: ["/app/server", "-migrate-only"]
depends_on:
postgres:
condition: service_healthy
environment:
DATABASE_URL: postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable
# LAB 5: migrate не имеет HTTP-эндпоинтов, healthcheck из Dockerfile отключён.
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: '0.50'
memory: 128M
api:
build:
context: .
dockerfile: Dockerfile
deploy:
replicas: 2
resources:
limits:
cpus: '0.50'
memory: 256M
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
rustfs:
condition: service_started
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
DATABASE_URL: postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
CACHE_MODE: ${CACHE_MODE:-versioned}
SESSION_STORE: ${SESSION_STORE:-redis}
S3_ENDPOINT: rustfs:9000
S3_ACCESS_KEY: ${S3_ACCESS_KEY:-minioadmin}
S3_SECRET_KEY: ${S3_SECRET_KEY:-minioadmin}
S3_BUCKET: ${S3_BUCKET:-messenger}
S3_USE_SSL: "false"
healthcheck:
test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health/ready"]
interval: 2s
timeout: 2s
retries: 3
start_period: 5s
# LAB 5: отдельный процесс обработки. Не принимает HTTP; потребляет очередь,
# строит варианты, пишет результаты. Память 512M: декодирование до 40 Мп
# (~160 MiB RGBA) плюс промежуточные кадры укладываются в лимит.
worker:
build:
context: .
dockerfile: Dockerfile
entrypoint: ["/app/server", "-worker"]
deploy:
replicas: 1
resources:
limits:
cpus: '0.50'
memory: 512M
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
rustfs:
condition: service_started
environment:
DATABASE_URL: postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable
REDIS_URL: redis://redis:6379/0
S3_ENDPOINT: rustfs:9000
S3_ACCESS_KEY: ${S3_ACCESS_KEY:-minioadmin}
S3_SECRET_KEY: ${S3_SECRET_KEY:-minioadmin}
S3_BUCKET: ${S3_BUCKET:-messenger}
S3_USE_SSL: "false"
# LAB 5: worker не имеет HTTP-эндпоинтов, healthcheck из Dockerfile отключён.
# Живость проверяется через docker ps (процесс запущен).
healthcheck:
disable: true
# LAB 5 (уровень 4): периодическая сверка S3 <-> PostgreSQL.
# Удаляет осиротевшие объекты (есть в бакете, нет метаданных в БД) старше
# grace period. Закрывает окно краха процесса между S3 PUT и DB COMMIT.
# Запускается ТОЛЬКО вручную (profiles: tools), стенд поднимается без него.
reconcile:
build:
context: .
dockerfile: Dockerfile
entrypoint: ["/app/server", "-reconcile"]
depends_on:
postgres:
condition: service_healthy
rustfs:
condition: service_started
environment:
DATABASE_URL: postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable
S3_ENDPOINT: rustfs:9000
S3_ACCESS_KEY: ${S3_ACCESS_KEY:-minioadmin}
S3_SECRET_KEY: ${S3_SECRET_KEY:-minioadmin}
S3_BUCKET: ${S3_BUCKET:-messenger}
S3_USE_SSL: "false"
RECONCILE_GRACE_PERIOD_SECONDS: ${RECONCILE_GRACE_PERIOD_SECONDS:-3600}
profiles:
- tools
# LAB 5: reconcile не имеет HTTP-эндпоинтов, healthcheck из Dockerfile отключён.
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: '0.50'
memory: 128M
nginx:
image: nginx:1.25-alpine
ports:
- "8080:8080"
depends_on:
api:
condition: service_healthy
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
deploy:
resources:
limits:
cpus: '0.25'
memory: 64M
volumes:
postgres_data:
redis_data:
rustfs_data:
+58
View File
@@ -0,0 +1,58 @@
worker_processes auto;
events {
worker_connections 1024;
}
http {
# Встроенный DNS Docker. КЛЮЧЕВОЕ для замечания ревью лабы 3:
# перерезолвинг каждые 10 секунд, поэтому после замены/масштабирования
# контейнеров nginx сам подхватывает новые адреса реплик.
resolver 127.0.0.11 valid=10s ipv6=off;
resolver_timeout 3s;
access_log /dev/stdout;
error_log /dev/stderr warn;
server {
listen 8080;
server_name _;
# LAB 4: лимит размера тела. Контракт разрешает ≤10 MiB (10 485 760 байт).
# Задаём с запасом 15M, чтобы заголовки и мелкие накладные расходы не резали
# легитимный запрос на границе. Реальный лимит 10 MiB применяется в
# uploadAttachment через http.MaxBytesReader — до полного чтения.
client_max_body_size 15M;
location / {
# Переменная ОБЯЗАТЕЛЬНА: именно она включает динамический резолвинг.
# Со статичным proxy_pass адрес резолвится один раз при старте —
# это и была причина замечания ревью лабы 3.
set $backend "http://api:8080";
proxy_pass $backend;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Connection "";
# LAB 4: стриминг тела вложения на upstream без буферизации.
# Без этого nginx читает всё тело в RAM перед отправкой в api —
# нарушает требование "потоковая обработка не позволяет одной
# загрузке занять неограниченную RAM" (уровень 4).
proxy_request_buffering off;
# Увеличенные таймауты для загрузки/скачивания вложений.
proxy_connect_timeout 2s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
# Failover: при ошибке на одной реплике пробуем следующую
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 5s;
}
}
}
+132
View File
@@ -0,0 +1,132 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-failover
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=fo%RND%
call :register "%U%" "Failover" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Failover chat\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Upload, capture replica via X-Instance-Id header ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=failover.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" ^
-D "%TMP%\upload.headers" ^
-o "%TMP%\att.json" ^
-w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload"
if errorlevel 1 exit /b 1
for /f "tokens=1,* delims=:" %%a in ('findstr /i "X-Instance-Id" "%TMP%\upload.headers"') do set UPLOAD_INSTANCE=%%b
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
echo Uploaded by:%UPLOAD_INSTANCE%
if "%ATT_ID%"=="" (
echo FAIL: attachment id is empty. Response body:
type "%TMP%\att.json"
echo.
echo Response headers:
type "%TMP%\upload.headers"
exit /b 1
)
echo attachment=%ATT_ID%
echo === Wait for ready ===
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ $m | ConvertTo-Json -Depth 6 | Set-Content '%TMP%\meta.json'; exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: not ready in 60s & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).sha256"') do set EXPECTED_SHA=%%a
echo expected sha256=%EXPECTED_SHA%
echo === Stop one API replica ===
set STOP_ID=
for /f "delims=" %%i in ('docker compose ps -q api') do if not defined STOP_ID set STOP_ID=%%i
if "%STOP_ID%"=="" ( echo FAIL: no api containers & exit /b 1 )
echo Stopping %STOP_ID%
docker stop --time 10 %STOP_ID% >nul
timeout /t 5 /nobreak >nul
echo === Download via remaining replica (with retries) ===
set TRY=0
:dl_retry
set /a TRY+=1
if %TRY% GTR 15 (
echo FAIL: download did not recover after replica stop
docker compose --compatibility up -d api >nul
exit /b 1
)
curl.exe -s -X GET "%BASE%/api/v1/attachments/%ATT_ID%/content" ^
-H "Authorization: Bearer %TOKEN%" ^
-D "%TMP%\dl.headers" ^
-o "%TMP%\dl.bin" ^
-w "%%{http_code}" > "%TMP%\dl.code"
set /p RC=<"%TMP%\dl.code"
if "%RC%"=="200" goto dl_ok
echo Download attempt %TRY% got HTTP %RC%, retrying...
timeout /t 1 /nobreak >nul
goto dl_retry
:dl_ok
for /f "tokens=1,* delims=:" %%a in ('findstr /i "X-Instance-Id" "%TMP%\dl.headers"') do set DL_INSTANCE=%%b
echo Downloaded by:%DL_INSTANCE%
powershell -NoProfile -Command "$h=[Security.Cryptography.SHA256]::Create(); $bytes=[IO.File]::ReadAllBytes('%TMP%\dl.bin'); $sha=[BitConverter]::ToString($h.ComputeHash($bytes)).Replace('-','').ToLower(); if($sha -ne '%EXPECTED_SHA%'){ exit 1 } else { exit 0 }"
if errorlevel 1 (
echo FAIL: downloaded sha256 mismatch after failover
docker compose --compatibility up -d api >nul
exit /b 1
)
echo PASS: original bytes available after stopping one replica
echo === Restore API replicas ===
docker compose --compatibility up -d api
timeout /t 15 /nobreak >nul
docker compose ps
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+113
View File
@@ -0,0 +1,113 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-lease
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=lease%RND%
call :register "%U%" "Lease" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Lease expiry\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Stop worker and upload (job stays queued) ===
docker compose --compatibility stop worker
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload"
if errorlevel 1 ( docker compose --compatibility up -d & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
echo attachment=%ATT_ID%
echo === CASE A: expired lease on attempt 5 must become failed ===
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "UPDATE jobs SET status='processing', attempt=5, lease_id='injected', lease_expires_at=now()-interval '2 minutes' WHERE attachment_id='%ATT_ID%'; UPDATE attachments SET status='processing' WHERE id='%ATT_ID%'; SELECT 'injected'"`) do set INJ=%%a
echo injection=%INJ%
docker compose --compatibility start worker
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'failed'){ $m | ConvertTo-Json -Depth 6 | Set-Content '%TMP%\a.json'; exit 0 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 (
echo FAIL: expired lease on attempt 5 did not become failed
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT status || ':' || attempt FROM jobs WHERE attachment_id='%ATT_ID%'"`) do echo job state = %%a
exit /b 1
)
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\a.json' -Raw | ConvertFrom-Json).error_code"') do set ECODE=%%a
echo PASS: case A failed with error_code=%ECODE%
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT status || ':' || attempt FROM jobs WHERE attachment_id='%ATT_ID%'"`) do set JSTATE=%%a
echo job state after = %JSTATE%
if not "%JSTATE%"=="failed:5" ( echo FAIL: expected failed:5, got %JSTATE% & exit /b 1 )
echo PASS: job row is failed:5 (no stuck processing:5)
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT count(*) FROM job_failures WHERE attachment_id='%ATT_ID%'"`) do set FC=%%a
if "%FC%"=="0" ( echo FAIL: no job_failures row for case A & exit /b 1 )
echo PASS: job_failures has %FC% row(s)
echo === CASE B: expired lease on attempt 2 must be requeued and reach ready ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample2.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att2.json" -w "%%{http_code}" > "%TMP%\att2.code"
call :check_code att2.code 202 "upload 2"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att2.json' -Raw | ConvertFrom-Json).id"') do set ATT2=%%a
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "UPDATE jobs SET status='processing', attempt=2, lease_id='injected', lease_expires_at=now()-interval '2 minutes' WHERE attachment_id='%ATT2%'; UPDATE attachments SET status='processing' WHERE id='%ATT2%'; SELECT 'injected'"`) do set INJ2=%%a
echo injection=%INJ2%
powershell -NoProfile -Command "for($i=0;$i -lt 90;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT2%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: case B did not reach ready & exit /b 1 )
echo PASS: case B requeued after lease expiry and reached ready
echo === No conn busy in worker logs ===
docker compose logs worker --tail 300 > "%TMP%\worker.log" 2>&1
findstr /i /c:"conn busy" "%TMP%\worker.log" >nul
if not errorlevel 1 ( echo FAIL: conn busy still present in worker logs & exit /b 1 )
echo PASS: no conn busy in worker logs
echo.
echo LEASE-EXPIRY CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+133
View File
@@ -0,0 +1,133 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-manual
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set ALICE=alice%RND%
set BOB=bob%RND%
set EVE=eve%RND%
echo === Register + login ===
call :register "%ALICE%" "Alice" alice
if errorlevel 1 exit /b 1
set ALICE_ID=!alice_ID!
call :register "%BOB%" "Bob" bob
if errorlevel 1 exit /b 1
set BOB_ID=!bob_ID!
call :register "%EVE%" "Eve" eve
if errorlevel 1 exit /b 1
call :login "%ALICE%" alice
if errorlevel 1 exit /b 1
set ALICE_TOKEN=!alice_TOKEN!
call :login "%BOB%" bob
if errorlevel 1 exit /b 1
set BOB_TOKEN=!bob_TOKEN!
call :login "%EVE%" eve
if errorlevel 1 exit /b 1
set EVE_TOKEN=!eve_TOKEN!
echo === Create chat ===
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %ALICE_TOKEN%" ^
-H "Content-Type: application/json" ^
-d "{\"title\":\"Lab5 manual\",\"member_ids\":[\"%ALICE_ID%\",\"%BOB_ID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Upload: expect 202 queued ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" ^
-H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" ^
-o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload returns 202"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).status"') do set UP_STATUS=%%a
if not "%UP_STATUS%"=="queued" (
echo FAIL: upload status must be queued, got %UP_STATUS%
exit /b 1
)
echo PASS: upload returned 202 queued, attachment=%ATT_ID%
echo === Poll until ready ===
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %BOB_TOKEN%'}; if($m.status -eq 'ready' -or $m.status -eq 'failed'){ $m | ConvertTo-Json -Depth 6 | Set-Content '%TMP%\meta.json'; exit 0 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 (
echo FAIL: attachment did not reach terminal state in 60s
exit /b 1
)
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).status"') do set RD_STATUS=%%a
if not "%RD_STATUS%"=="ready" (
echo FAIL: attachment status is %RD_STATUS%, expected ready
exit /b 1
)
echo PASS: attachment became ready
echo === Validate variants (thumbnail 256x160 jpeg, crop 128x128 jpeg, optimized webp) ===
powershell -NoProfile -Command "$m=Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json; $t=$m.variants | Where-Object name -eq 'thumbnail'; $c=$m.variants | Where-Object name -eq 'crop'; $o=$m.variants | Where-Object name -eq 'optimized'; if(($m.variants | Measure-Object).Count -ne 3){ Write-Host 'FAIL: expected 3 variants'; exit 1 }; if(-not $t -or $t.width -ne 256 -or $t.height -ne 160 -or $t.content_type -ne 'image/jpeg'){ Write-Host 'FAIL: thumbnail wrong'; exit 1 }; if(-not $c -or $c.width -ne 128 -or $c.height -ne 128 -or $c.content_type -ne 'image/jpeg'){ Write-Host 'FAIL: crop wrong'; exit 1 }; if(-not $o -or $o.content_type -ne 'image/webp'){ Write-Host 'FAIL: optimized wrong'; exit 1 }; Write-Host 'PASS: variants metadata correct'"
if errorlevel 1 exit /b 1
echo === Download each variant and compare sha256 ===
powershell -NoProfile -Command "$m=Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json; $h=@{Authorization='Bearer %BOB_TOKEN%'}; foreach($v in $m.variants){ $r=Invoke-WebRequest -Uri ('%BASE%/api/v1/attachments/%ATT_ID%/content?variant='+$v.name) -Headers $h -UseBasicParsing; $sha=[BitConverter]::ToString([Security.Cryptography.SHA256]::Create().ComputeHash($r.Content)).Replace('-','').ToLower(); if($sha -ne $v.sha256){ Write-Host ('FAIL: sha mismatch for '+$v.name); exit 1 }; if($r.Headers['Content-Type'] -ne $v.content_type){ Write-Host ('FAIL: content-type mismatch for '+$v.name); exit 1 }; Write-Host ('PASS: variant '+$v.name+' bytes and content-type match') }; $r=Invoke-WebRequest -Uri '%BASE%/api/v1/attachments/%ATT_ID%/content' -Headers $h -UseBasicParsing; $sha=[BitConverter]::ToString([Security.Cryptography.SHA256]::Create().ComputeHash($r.Content)).Replace('-','').ToLower(); if($sha -ne $m.sha256){ Write-Host 'FAIL: original sha mismatch'; exit 1 }; Write-Host 'PASS: original bytes match'"
if errorlevel 1 exit /b 1
echo === Eve gets 404 on metadata and content ===
curl.exe -s -o nul -H "Authorization: Bearer %EVE_TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%" > "%TMP%\eve_meta.code"
call :check_code eve_meta.code 404 "eve metadata"
if errorlevel 1 exit /b 1
curl.exe -s -o nul -H "Authorization: Bearer %EVE_TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%/content" > "%TMP%\eve_content.code"
call :check_code eve_content.code 404 "eve content"
if errorlevel 1 exit /b 1
echo === Message with attachment_ids ===
call :guid
set KEY=%GUIDVAL%
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/messages" ^
-H "Authorization: Bearer %ALICE_TOKEN%" ^
-H "Idempotency-Key: %KEY%" ^
-H "Content-Type: application/json" ^
-d "{\"text\":\"\",\"attachment_ids\":[\"%ATT_ID%\"]}" ^
-o "%TMP%\msg.json" -w "%%{http_code}" > "%TMP%\msg.code"
call :check_code msg.code 201 "create message with attachment"
if errorlevel 1 exit /b 1
echo.
echo ALL MANUAL LAB5 CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+147
View File
@@ -0,0 +1,147 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-negative
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set ALICE=alice%RND%
set BOB=bob%RND%
set EVE=eve%RND%
call :register "%ALICE%" "Alice" alice
if errorlevel 1 exit /b 1
set ALICE_ID=!alice_ID!
call :register "%BOB%" "Bob" bob
if errorlevel 1 exit /b 1
set BOB_ID=!bob_ID!
call :register "%EVE%" "Eve" eve
if errorlevel 1 exit /b 1
call :login "%ALICE%" alice
if errorlevel 1 exit /b 1
set ALICE_TOKEN=!alice_TOKEN!
call :login "%EVE%" eve
if errorlevel 1 exit /b 1
set EVE_TOKEN=!eve_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Neg chat1\",\"member_ids\":[\"%ALICE_ID%\",\"%BOB_ID%\"]}" ^
-o "%TMP%\chat1.json" -w "%%{http_code}" > "%TMP%\chat1.code"
call :check_code chat1.code 201 "create chat1"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat1.json' -Raw | ConvertFrom-Json).id"') do set CHAT1_ID=%%a
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Neg chat2\",\"member_ids\":[\"%ALICE_ID%\",\"%EVE_ID%\"]}" ^
-o "%TMP%\chat2.json" -w "%%{http_code}" > "%TMP%\chat2.code"
call :check_code chat2.code 201 "create chat2"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat2.json' -Raw | ConvertFrom-Json).id"') do set CHAT2_ID=%%a
echo === 1. Too large file 413 ===
powershell -NoProfile -Command "$sig=[byte[]](0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A); $pad=New-Object byte[] (11534336-8); [IO.File]::WriteAllBytes('%TMP%\large.png', $sig+$pad)"
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/attachments?filename=large.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%TMP%\large.png" -w "%%{http_code}" > "%TMP%\large.code"
call :check_code large.code 413 "too large upload"
if errorlevel 1 exit /b 1
echo === 2. Broken image 415 ===
powershell -NoProfile -Command "[IO.File]::WriteAllBytes('%TMP%\broken.png',[byte[]](0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,0xFF,0xFF,0xFF,0xFF))"
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/attachments?filename=broken.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%TMP%\broken.png" -w "%%{http_code}" > "%TMP%\broken.code"
call :check_code broken.code 415 "broken png"
if errorlevel 1 exit /b 1
echo === 3. MIME mismatch 415 ===
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/attachments?filename=fake.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: image/jpeg" ^
--data-binary "@%FIXTURE%" -w "%%{http_code}" > "%TMP%\mime.code"
call :check_code mime.code 415 "jpeg disguised as png"
if errorlevel 1 exit /b 1
echo === 4. Dangerous filename 400 ===
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/attachments?filename=..%%2Fevil.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -w "%%{http_code}" > "%TMP%\filename.code"
call :check_code filename.code 400 "path traversal filename"
if errorlevel 1 exit /b 1
echo === 5. Valid upload, wait ready ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "valid upload"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %ALICE_TOKEN%'}; if($m.status -eq 'ready' -or $m.status -eq 'failed'){ exit 0 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: not ready in 60s & exit /b 1 )
echo === 6. Unknown variant 404 ===
curl.exe -s -o nul -H "Authorization: Bearer %ALICE_TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%/content?variant=nope" > "%TMP%\variant.code"
call :check_code variant.code 404 "unknown variant"
if errorlevel 1 exit /b 1
echo === 7. Cross-chat reference 404 ===
call :guid
set KEY1=%GUIDVAL%
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT2_ID%/messages" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Idempotency-Key: %KEY1%" -H "Content-Type: application/json" ^
-d "{\"text\":\"\",\"attachment_ids\":[\"%ATT_ID%\"]}" -w "%%{http_code}" > "%TMP%\crosschat.code"
call :check_code crosschat.code 404 "cross-chat attachment reference"
if errorlevel 1 exit /b 1
echo === 8. Unknown attachment id 404 ===
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString()"') do set UNKNOWN=%%a
call :guid
set KEY2=%GUIDVAL%
curl.exe -s -o nul -X POST "%BASE%/api/v1/chats/%CHAT1_ID%/messages" ^
-H "Authorization: Bearer %ALICE_TOKEN%" -H "Idempotency-Key: %KEY2%" -H "Content-Type: application/json" ^
-d "{\"text\":\"\",\"attachment_ids\":[\"%UNKNOWN%\"]}" -w "%%{http_code}" > "%TMP%\unknown.code"
call :check_code unknown.code 404 "unknown attachment id"
if errorlevel 1 exit /b 1
echo === 9. Eve download 404 ===
curl.exe -s -o nul -H "Authorization: Bearer %EVE_TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%/content" > "%TMP%\eve_dl.code"
call :check_code eve_dl.code 404 "eve download"
if errorlevel 1 exit /b 1
echo.
echo ALL NEGATIVE CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+87
View File
@@ -0,0 +1,87 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-persistence
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=pers%RND%
call :register "%U%" "Persistence" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Persistence chat\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
echo === Waiting for ready ===
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ $m | ConvertTo-Json -Depth 6 | Set-Content '%TMP%\meta.json'; exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: not ready in 60s & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).sha256"') do set SHA256=%%a
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).variants | ForEach-Object { $_.name + ':' + $_.sha256 }"') do (
echo %%a>> "%TMP%\variants.txt"
)
>"%TMP%\token.txt" echo %TOKEN%
>"%TMP%\chat_id.txt" echo %CHAT_ID%
>"%TMP%\att_id.txt" echo %ATT_ID%
>"%TMP%\sha256.txt" echo %SHA256%
echo.
echo State saved to %TMP%
echo attachment=%ATT_ID%
echo original sha256=%SHA256%
type "%TMP%\variants.txt"
echo.
echo Now run:
echo scripts\restart-stack.bat
echo scripts\persistence-verify.bat
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+59
View File
@@ -0,0 +1,59 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set TMP=%TEMP%\lab5-persistence
if not exist "%TMP%\token.txt" (
echo FAIL: state not found. Run scripts\persistence-attachment.bat first.
exit /b 1
)
set /p TOKEN=<"%TMP%\token.txt"
set /p CHAT_ID=<"%TMP%\chat_id.txt"
set /p ATT_ID=<"%TMP%\att_id.txt"
set /p EXPECTED_SHA=<"%TMP%\sha256.txt"
echo === Persistence verify after restart ===
echo chat=%CHAT_ID%
echo attachment=%ATT_ID%
echo expected original sha256=%EXPECTED_SHA%
echo === Check metadata ===
curl.exe -s -X GET "%BASE%/api/v1/attachments/%ATT_ID%" ^
-H "Authorization: Bearer %TOKEN%" ^
-o "%TMP%\meta.json" -w "%%{http_code}" > "%TMP%\meta.code"
set /p RC=<"%TMP%\meta.code"
if not "%RC%"=="200" ( echo FAIL: metadata HTTP %RC% & type "%TMP%\meta.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).sha256"') do set META_SHA=%%a
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).status"') do set ST=%%a
if not "%ST%"=="ready" ( echo FAIL: status is %ST%, expected ready & exit /b 1 )
if not "%META_SHA%"=="%EXPECTED_SHA%" ( echo FAIL: metadata sha256 mismatch & exit /b 1 )
echo PASS: attachment metadata survived restart (status=ready, sha256 matches)
echo === Check original bytes ===
curl.exe -s -X GET "%BASE%/api/v1/attachments/%ATT_ID%/content" ^
-H "Authorization: Bearer %TOKEN%" ^
-o "%TMP%\original.bin" -w "%%{http_code}" > "%TMP%\original.code"
set /p RC=<"%TMP%\original.code"
if not "%RC%"=="200" ( echo FAIL: original HTTP %RC% & exit /b 1 )
powershell -NoProfile -Command "$h=[Security.Cryptography.SHA256]::Create(); $bytes=[IO.File]::ReadAllBytes('%TMP%\original.bin'); $sha=[BitConverter]::ToString($h.ComputeHash($bytes)).Replace('-','').ToLower(); if($sha -ne '%EXPECTED_SHA%'){ exit 1 } else { exit 0 }"
if errorlevel 1 ( echo FAIL: original sha256 mismatch & exit /b 1 )
echo PASS: original bytes survived restart
echo === Check each variant bytes ===
powershell -NoProfile -Command "$m=Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json; $h=@{Authorization='Bearer %TOKEN%'}; foreach($v in $m.variants){ $r=Invoke-WebRequest -Uri ('%BASE%/api/v1/attachments/%ATT_ID%/content?variant='+$v.name) -Headers $h -UseBasicParsing; $sha=[BitConverter]::ToString([Security.Cryptography.SHA256]::Create().ComputeHash($r.Content)).Replace('-','').ToLower(); if($sha -ne $v.sha256){ Write-Host ('FAIL: variant '+$v.name+' sha256 mismatch'); exit 1 }; Write-Host ('PASS: variant '+$v.name+' bytes survived restart') }"
if errorlevel 1 exit /b 1
echo === Check old session token still works ===
curl.exe -s -o nul -H "Authorization: Bearer %TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/chats/%CHAT_ID%/messages?limit=1" > "%TMP%\msg.code"
set /p RC=<"%TMP%\msg.code"
if not "%RC%"=="200" ( echo FAIL: messages HTTP %RC%, token may have expired & exit /b 1 )
echo PASS: old session token still works
echo.
echo ALL PERSISTENCE CHECKS PASSED
exit /b 0
+35
View File
@@ -0,0 +1,35 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set TMP=%TEMP%\lab5-private
if not exist "%TMP%" mkdir "%TMP%"
echo === Private bucket check (original + thumbnail) ===
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT s3_key FROM attachments WHERE status='ready' ORDER BY created_at DESC LIMIT 1"`) do set KEY=%%a
if "%KEY%"=="" (
echo FAIL: no ready attachments found. Run scripts\manual-attachments.bat first.
exit /b 1
)
echo Latest original key: %KEY%
docker compose exec -T api sh -lc "wget -S -O /dev/null http://rustfs:9000/messenger/%KEY% 2>&1" > "%TMP%\out1.txt" 2>&1
findstr /c:"HTTP/1.1 200" "%TMP%\out1.txt" >nul
if not errorlevel 1 ( echo FAIL: original is publicly readable & type "%TMP%\out1.txt" & exit /b 1 )
echo PASS: original not publicly readable
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT chat_id || '/' || id || '/thumbnail' FROM attachments WHERE status='ready' ORDER BY created_at DESC LIMIT 1"`) do set TKEY=%%a
if "%TKEY%"=="" (
echo FAIL: no ready attachment for thumbnail check
exit /b 1
)
echo Latest thumbnail key: %TKEY%
docker compose exec -T api sh -lc "wget -S -O /dev/null http://rustfs:9000/messenger/%TKEY% 2>&1" > "%TMP%\out2.txt" 2>&1
findstr /c:"HTTP/1.1 200" "%TMP%\out2.txt" >nul
if not errorlevel 1 ( echo FAIL: thumbnail is publicly readable & type "%TMP%\out2.txt" & exit /b 1 )
echo PASS: thumbnail not publicly readable
echo.
echo PRIVATE BUCKET CHECKS PASSED
exit /b 0
+102
View File
@@ -0,0 +1,102 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-reconcile
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=rec%RND%
call :register "%U%" "Reconcile" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Reconcile demo\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Upload and wait ready (creates S3 objects + DB metadata) ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).chat_id"') do set CHAT_ID=%%a
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: not ready in 60s & exit /b 1 )
echo attachment=%ATT_ID% reached ready
echo === Count S3 objects for this attachment before deletion ===
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT count(*) FROM attachments WHERE id='%ATT_ID%'"`) do set BEFORE_DB=%%a
echo DB rows before: %BEFORE_DB%
echo === Simulate crash: delete DB rows for this attachment, leave S3 objects orphaned ===
docker compose exec -T postgres psql -U messenger -d messenger -c "DELETE FROM attachments WHERE id='%ATT_ID%';"
docker compose exec -T postgres psql -U messenger -d messenger -c "DELETE FROM jobs WHERE attachment_id='%ATT_ID%';"
docker compose exec -T postgres psql -U messenger -d messenger -c "DELETE FROM job_failures WHERE attachment_id='%ATT_ID%';"
echo === List objects that became orphaned ===
docker compose exec -T rustfs sh -lc "find /data/messenger/staging/%CHAT_ID%/%ATT_ID% /data/messenger/%CHAT_ID%/%ATT_ID% -type f 2>/dev/null" || echo "(rustfs find skipped)"
echo === Run reconcile with grace=0 (must delete orphaned objects) ===
docker compose --compatibility --profile tools run -e RECONCILE_GRACE_PERIOD_SECONDS=0 --rm reconcile
if errorlevel 1 (
echo FAIL: reconcile exited non-zero
exit /b 1
)
echo === Run reconcile again (idempotent: 0 orphans deleted) ===
docker compose --compatibility --profile tools run -e RECONCILE_GRACE_PERIOD_SECONDS=0 --rm reconcile
if errorlevel 1 exit /b 1
echo.
echo RECONCILE DEMO COMPLETE.
echo In the first run log look for "reconcile deleted orphan" with 4-5 keys:
echo staging/%CHAT_ID%/%ATT_ID%
echo %CHAT_ID%/%ATT_ID%/original
echo %CHAT_ID%/%ATT_ID%/thumbnail
echo %CHAT_ID%/%ATT_ID%/crop
echo %CHAT_ID%/%ATT_ID%/optimized
echo In the second run log look for "orphans_deleted 0" (or "deleted 0").
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+27
View File
@@ -0,0 +1,27 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set TMP=%TEMP%\lab5-restart
if not exist "%TMP%" mkdir "%TMP%"
echo === Restarting stack without removing volumes ===
docker compose --compatibility restart
echo === Waiting for /health/ready ===
set COUNT=0
:wait
set /a COUNT+=1
if %COUNT% GTR 90 (
echo FAIL: stack did not become ready in 90s
exit /b 1
)
curl.exe -s -o nul -w "%%{http_code}" http://localhost:8080/health/ready > "%TMP%\code.txt"
set /p C=<"%TMP%\code.txt"
if "%C%"=="200" (
echo Stack is ready.
exit /b 0
)
timeout /t 1 /nobreak >nul
goto wait
+111
View File
@@ -0,0 +1,111 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-retryfail
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=user%RND%
call :register "%U%" "RetryFail" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Retry fail\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Stop worker so the job cannot complete ===
docker compose --compatibility stop worker
echo === Upload while worker down: job stays queued ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload"
if errorlevel 1 ( docker compose --compatibility up -d & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
echo === Stop rustfs, then start ONLY the worker container ===
docker compose --compatibility stop rustfs
set WID=
for /f "delims=" %%i in ('docker ps -a --filter "name=worker" --format "{{.ID}}"') do if not defined WID set WID=%%i
if "%WID%"=="" (
echo FAIL: worker container not found
docker compose --compatibility up -d
exit /b 1
)
docker start %WID% >nul
echo === Wait for terminal failed (retry exhaustion, up to 180s) ===
powershell -NoProfile -Command "for($i=0;$i -lt 180;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'failed'){ $m | ConvertTo-Json -Depth 6 | Set-Content '%TMP%\meta.json'; exit 0 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 (
echo FAIL: attachment did not reach failed in 180s
docker compose --compatibility up -d
exit /b 1
)
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).error_code"') do set ECODE=%%a
echo PASS: attachment reached failed with error_code=%ECODE%
echo === job_failures registry has a row ===
for /f "usebackq delims=" %%a in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT count(*) FROM job_failures WHERE attachment_id='%ATT_ID%'"`) do set FCOUNT=%%a
if "%FCOUNT%"=="0" (
echo FAIL: no job_failures row
docker compose --compatibility up -d
exit /b 1
)
echo PASS: job_failures contains %FCOUNT% row(s)
echo === Restore stack; status stays terminal failed ===
docker compose --compatibility up -d
timeout /t 15 /nobreak >nul
curl.exe -s -H "Authorization: Bearer %TOKEN%" "%BASE%/api/v1/attachments/%ATT_ID%" -o "%TMP%\meta2.json"
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta2.json' -Raw | ConvertFrom-Json).status"') do set ST2=%%a
if not "%ST2%"=="failed" (
echo FAIL: expected terminal failed after restore, got %ST2%
exit /b 1
)
echo PASS: failed is terminal, no silent reprocessing
echo.
echo RETRY-FAIL CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+6
View File
@@ -0,0 +1,6 @@
@echo off
setlocal
cd /d "%~dp0.."
set PYTHONUTF8=1
python -X utf8 tests\smoke.py --base-url http://localhost:8080
exit /b %ERRORLEVEL%
+107
View File
@@ -0,0 +1,107 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-truncated
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=trunc%RND%
call :register "%U%" "Truncated" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Truncated images\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Build truncated PNG (valid IHDR, cut IDAT, no IEND) ===
powershell -NoProfile -Command "$b=[IO.File]::ReadAllBytes('%FIXTURE%'); $cut=[int]($b.Length*0.6); $out=New-Object byte[] $cut; [Array]::Copy($b,0,$out,0,$cut); [IO.File]::WriteAllBytes('%TMP%\truncated.png',$out); Write-Host ('truncated.png bytes='+$cut+' of '+$b.Length)"
echo === Truncated PNG must be rejected with 415 at upload ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=truncated.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%TMP%\truncated.png" ^
-o "%TMP%\png.json" -w "%%{http_code}" > "%TMP%\png.code"
call :check_code png.code 415 "truncated png rejected at upload"
if errorlevel 1 ( type "%TMP%\png.json" & exit /b 1 )
echo PASS: truncated PNG returned 415 (not 202)
echo === Build valid JPEG, then truncate it ===
powershell -NoProfile -Command "Add-Type -AssemblyName System.Drawing; $bmp=New-Object System.Drawing.Bitmap 64,64; for($x=0;$x -lt 64;$x++){ for($y=0;$y -lt 64;$y++){ $bmp.SetPixel($x,$y,[System.Drawing.Color]::FromArgb(($x*4),($y*4),128)) } }; $bmp.Save('%TMP%\full.jpg',[System.Drawing.Imaging.ImageFormat]::Jpeg); $bmp.Dispose(); $b=[IO.File]::ReadAllBytes('%TMP%\full.jpg'); $cut=[int]($b.Length*0.6); $out=New-Object byte[] $cut; [Array]::Copy($b,0,$out,0,$cut); [IO.File]::WriteAllBytes('%TMP%\truncated.jpg',$out); Write-Host ('truncated.jpg bytes='+$cut+' of '+$b.Length)"
echo === Truncated JPEG must be rejected with 415 at upload ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=truncated.jpg" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/jpeg" ^
--data-binary "@%TMP%\truncated.jpg" ^
-o "%TMP%\jpg.json" -w "%%{http_code}" > "%TMP%\jpg.code"
call :check_code jpg.code 415 "truncated jpeg rejected at upload"
if errorlevel 1 ( type "%TMP%\jpg.json" & exit /b 1 )
echo PASS: truncated JPEG returned 415 (not 202)
echo === Valid JPEG still accepted with 202 (no false positives) ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=full.jpg" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/jpeg" ^
--data-binary "@%TMP%\full.jpg" ^
-o "%TMP%\ok.json" -w "%%{http_code}" > "%TMP%\ok.code"
call :check_code ok.code 202 "valid jpeg accepted"
if errorlevel 1 ( type "%TMP%\ok.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\ok.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: valid jpeg did not reach ready & exit /b 1 )
echo PASS: valid JPEG reached ready
echo === Valid PNG still accepted (fixture regression) ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" ^
-o "%TMP%\png_ok.json" -w "%%{http_code}" > "%TMP%\png_ok.code"
call :check_code png_ok.code 202 "valid png accepted"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\png_ok.json' -Raw | ConvertFrom-Json).id"') do set PATT=%%a
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%PATT%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 ( echo FAIL: valid png did not reach ready & exit /b 1 )
echo PASS: valid PNG reached ready
echo.
echo TRUNCATED-IMAGE CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+101
View File
@@ -0,0 +1,101 @@
@echo off
setlocal EnableDelayedExpansion
cd /d "%~dp0.."
set BASE=http://localhost:8080
set PASS=Example-only-not-a-real-secret-123
set FIXTURE=tests\fixtures\sample.png
set TMP=%TEMP%\lab5-workerdown
if not exist "%TMP%" mkdir "%TMP%"
call :guid
set RND=%GUIDVAL%
set U=user%RND%
call :register "%U%" "WorkerDown" u
if errorlevel 1 exit /b 1
set UID=!u_ID!
call :login "%U%" u
if errorlevel 1 exit /b 1
set TOKEN=!u_TOKEN!
curl.exe -s -X POST "%BASE%/api/v1/chats" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: application/json" ^
-d "{\"title\":\"Worker down\",\"member_ids\":[\"%UID%\"]}" ^
-o "%TMP%\chat.json" -w "%%{http_code}" > "%TMP%\chat.code"
call :check_code chat.code 201 "create chat"
if errorlevel 1 exit /b 1
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\chat.json' -Raw | ConvertFrom-Json).id"') do set CHAT_ID=%%a
echo === Stop worker ===
docker compose --compatibility stop worker
timeout /t 3 /nobreak >nul
echo === Upload while worker down: expect 202 queued ===
curl.exe -s -X POST "%BASE%/api/v1/chats/%CHAT_ID%/attachments?filename=sample.png" ^
-H "Authorization: Bearer %TOKEN%" -H "Content-Type: image/png" ^
--data-binary "@%FIXTURE%" -o "%TMP%\att.json" -w "%%{http_code}" > "%TMP%\att.code"
call :check_code att.code 202 "upload with worker down"
if errorlevel 1 ( docker compose --compatibility start worker & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\att.json' -Raw | ConvertFrom-Json).id"') do set ATT_ID=%%a
echo === Status must stay queued for ~5s (API does not process synchronously) ===
timeout /t 5 /nobreak >nul
curl.exe -s -H "Authorization: Bearer %TOKEN%" "%BASE%/api/v1/attachments/%ATT_ID%" -o "%TMP%\meta.json"
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\meta.json' -Raw | ConvertFrom-Json).status"') do set ST=%%a
if not "%ST%"=="queued" (
echo FAIL: expected queued while worker down, got %ST%
docker compose --compatibility start worker
exit /b 1
)
echo PASS: status stayed queued with worker down
echo === Download before ready must be 409 ===
curl.exe -s -o nul -H "Authorization: Bearer %TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%/content" > "%TMP%\dl.code"
call :check_code dl.code 409 "download before ready"
if errorlevel 1 ( docker compose --compatibility start worker & exit /b 1 )
echo === Start worker and wait ready ===
docker compose --compatibility start worker
powershell -NoProfile -Command "for($i=0;$i -lt 60;$i++){ $m=Invoke-RestMethod -Uri '%BASE%/api/v1/attachments/%ATT_ID%' -Headers @{Authorization='Bearer %TOKEN%'}; if($m.status -eq 'ready'){ exit 0 }; if($m.status -eq 'failed'){ exit 2 }; Start-Sleep -Seconds 1 }; exit 1"
if errorlevel 1 (
echo FAIL: attachment did not become ready after worker restart
exit /b 1
)
echo PASS: job survived worker restart and reached ready
echo === Download now 200 ===
curl.exe -s -o "%TMP%\dl.png" -H "Authorization: Bearer %TOKEN%" -w "%%{http_code}" "%BASE%/api/v1/attachments/%ATT_ID%/content" > "%TMP%\dl2.code"
call :check_code dl2.code 200 "download after ready"
if errorlevel 1 exit /b 1
echo.
echo WORKER-DOWN CHECKS PASSED
exit /b 0
:guid
for /f "delims=" %%a in ('powershell -NoProfile -Command "[guid]::NewGuid().ToString('N').Substring(0,8)"') do set GUIDVAL=%%a
exit /b 0
:register
curl.exe -s -X POST "%BASE%/api/v1/users" ^
-H "Content-Type: application/json" ^
-d "{\"username\":\"%~1\",\"display_name\":\"%~2\",\"password\":\"%PASS%\"}" ^
-o "%TMP%\%~3.json" -w "%%{http_code}" > "%TMP%\%~3.code"
set /p RC=<"%TMP%\%~3.code"
if not "%RC%"=="201" ( echo FAIL: register %~1, HTTP %RC% & type "%TMP%\%~3.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~3.json' -Raw | ConvertFrom-Json).id"') do set "%~3_ID=%%a"
exit /b 0
:login
curl.exe -s -X POST "%BASE%/api/v1/auth/sessions" ^
-u "%~1:%PASS%" ^
-o "%TMP%\%~2.json" -w "%%{http_code}" > "%TMP%\%~2.code"
set /p RC=<"%TMP%\%~2.code"
if not "%RC%"=="201" ( echo FAIL: login %~1, HTTP %RC% & type "%TMP%\%~2.json" & exit /b 1 )
for /f "delims=" %%a in ('powershell -NoProfile -Command "(Get-Content '%TMP%\%~2.json' -Raw | ConvertFrom-Json).token"') do set "%~2_TOKEN=%%a"
exit /b 0
:check_code
set /p RC=<"%TMP%\%~1"
if not "%RC%"=="%~2" ( echo FAIL: %~3 expected %~2, got %RC% & exit /b 1 )
exit /b 0
+118
View File
@@ -0,0 +1,118 @@
# Демонстрация работоспособности (lab1, оценка 4)
Все команды — PowerShell. Контейнер запускаем один раз, дальше работаем во втором терминале.
## Шаг 0. Сборка, запуск
```powershell
docker build -t mtusi-messenger:lab1 .
docker run --rm -d --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
```
# → образ собрался; через ~10 c `docker ps` показывает Status: Up (healthy)
## Шаг 1. Health и публичные тесты
```powershell
Invoke-RestMethod http://localhost:8080/health/live # → status: ok
Invoke-RestMethod http://localhost:8080/health/ready # → status: ok
python tests/smoke.py --base-url http://localhost:8080
# → PASS: lab1 public API scenario...
python student-tests/run_tests.py --base-url http://localhost:8080
# → 25/25 PASS, ALL STUDENT TESTS PASSED
```
## Шаг 2. Пользователи (Unicode в display_name)
```powershell
$alice = Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes('{"username":"alice","display_name":"Алиса"}'))
$bob = Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes('{"username":"bob","display_name":"Боб"}'))
$carol = Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes('{"username":"carol","display_name":"Кэрол"}'))
$alice.id; $bob.id; $carol.id # → три UUID, 201 Created
```
## Шаг 3. Один чат на двоих, история из двух сообщений
```powershell
$chat = Invoke-RestMethod -Method Post http://localhost:8080/api/v1/chats -Headers @{"X-User-Id"=$alice.id} -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes((@{title="Проект по ВНП";member_ids=@($alice.id,$bob.id)} | ConvertTo-Json -Compress)))
Invoke-RestMethod -Method Post "http://localhost:8080/api/v1/chats/$($chat.id)/messages" -Headers @{"X-User-Id"=$alice.id} -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Привет, Боб!"}'))
Invoke-RestMethod -Method Post "http://localhost:8080/api/v1/chats/$($chat.id)/messages" -Headers @{"X-User-Id"=$bob.id} -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Здравствуй, Алиса!"}'))
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=50" -Headers @{"X-User-Id"=$bob.id}
# → items: 2 сообщения по возрастанию (created_at, id), next_cursor: null
```
## Шаг 4. Третий пользователь получает 404 (не 403)
```powershell
try { Invoke-RestMethod "http://localhost:8080/api/v1/chats/$($chat.id)" -Headers @{"X-User-Id"=$carol.id} }
catch { [int]$_.Exception.Response.StatusCode } # → 404
try { Invoke-RestMethod -Method Post "http://localhost:8080/api/v1/chats/$($chat.id)/messages" -Headers @{"X-User-Id"=$carol.id} -ContentType 'application/json' -Body '{"text":"hi"}' }
catch { [int]$_.Exception.Response.StatusCode } # → 404 (существование чужого чата не раскрывается)
```
## Шаг 5. Валидация и форматы ошибок
```powershell
try { Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body '{"username":' } catch { [int]$_.Exception.Response.StatusCode } # → 400 malformed JSON
try { Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body '{"username":"alice","display_name":"dup"}' } catch { [int]$_.Exception.Response.StatusCode } # → 409 дубликат username
try { Invoke-RestMethod -Method Post "http://localhost:8080/api/v1/chats/$($chat.id)/messages" -Headers @{"X-User-Id"=$alice.id} -ContentType 'application/json' -Body '{"text":" "}' } catch { [int]$_.Exception.Response.StatusCode } # → 400 пустое/пробельное сообщение
try { Invoke-RestMethod http://localhost:8080/api/v1/users/me } catch { [int]$_.Exception.Response.StatusCode } # → 401 без X-User-Id
# Тело любой ошибки: {"error":{"code":"...","message":"...","request_id":"..."}}, request_id == заголовок X-Request-Id
```
## Шаг 6. Пагинация курсором (обход нескольких страниц)
```powershell
1..25 | ForEach-Object { Invoke-RestMethod -Method Post "http://localhost:8080/api/v1/chats/$($chat.id)/messages" -Headers @{"X-User-Id"=$bob.id} -ContentType 'application/json' -Body ([Text.Encoding]::UTF8.GetBytes("{`"text`":`"msg-$_`"}")) } | Out-Null
$p1 = Invoke-RestMethod "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=10" -Headers @{"X-User-Id"=$alice.id}
$p1.items.Count # → 10
$p2 = Invoke-RestMethod "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=10&cursor=$($p1.next_cursor)" -Headers @{"X-User-Id"=$alice.id}
($p1.items.id | Where-Object { $p2.items.id -contains $_ }).Count # → 0 (повторов нет)
try { Invoke-RestMethod "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=101" -Headers @{"X-User-Id"=$alice.id} } catch { [int]$_.Exception.Response.StatusCode } # → 400 limit вне 1..100
```
## Шаг 7. Гонки: 10 клиентов × 10 сообщений = ровно 100 уникальных
```powershell
python student-tests/run_tests.py --base-url http://localhost:8080 2>&1 | Select-String "concurrent|unique"
# → [PASS] 100 concurrent sends all 201
# → [PASS] exactly 100 unique messages
```
## Шаг 8. Контейнер: non-root, healthcheck, логи без текстов сообщений
```powershell
docker exec mtusi-messenger-lab1 id
# → uid=100(app) gid=101(app) groups=101(app)
docker inspect --format "{{.State.Health.Status}}" mtusi-messenger-lab1
# → healthy
docker logs --tail 5 mtusi-messenger-lab1
# → JSON-логи: method/path/status/dur_ms/request_id; текстов сообщений и X-User-Id в логах нет
```
## Шаг 9. SIGTERM: корректное завершение быстрее 10 секунд
```powershell
docker run -d --name sigterm-demo -p 127.0.0.1:8081:8080 --env-file .env mtusi-messenger:lab1
Measure-Command { docker stop sigterm-demo }
# → TotalSeconds: ~0.5 (<< 10)
docker logs --tail 2 sigterm-demo
# → "shutdown signal received" → "server stopped cleanly"
docker rm sigterm-demo
```
## Шаг 10. Жизненный цикл: перезапуск контейнера сбрасывает память
```powershell
$u = Invoke-RestMethod -Method Post http://localhost:8080/api/v1/users -ContentType 'application/json' -Body '{"username":"ephemeral","display_name":"Temp"}'
Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers @{"X-User-Id"=$u.id} # → 200, пользователь есть
docker restart mtusi-messenger-lab1
Start-Sleep 5
try { Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers @{"X-User-Id"=$u.id} }
catch { [int]$_.Exception.Response.StatusCode } # → 401: пользователь исчез вместе с памятью процесса
```
## Уборка
```powershell
docker stop mtusi-messenger-lab1 # с --rm контейнер удалится сам
```
+312
View File
@@ -0,0 +1,312 @@
# Демонстрация — лабораторная 2 (PostgreSQL, сессии, Redis-кэш)
**Автор, группа:** BVT2304 Shiyan
**Целевая оценка:** 5 (уровни 3 + 4 + Трек 1 «Согласованность кэша»)
**Стенд:** Windows + Docker Desktop, PowerShell; все команды выполняются из корня репозитория.
**Секреты:** `.env` создаётся локально из `.env.example` и НЕ коммитится. Токены в командах ниже — подстановочные (`$T`), в Git не попадают.
Документ проводит защиту по сценарию README lab2: миграции к пустому volume → пользователи/вход/сообщение → persistence с токеном в памяти → expiry → роль Redis и ошибки зависимостей → план SQL → эксперимент трека 5. Каждый шаг: команда → ожидаемый вывод → что это доказывает.
---
## Шаг 0. Чистый старт: миграции к пустому volume
```powershell
cd C:\Users\maksimator\GolandProjects\mtusi2026lab2
# НАМЕРЕННОЕ удаление учебных данных (volume): доказываем, что схема строится с нуля
docker compose down -v
# Сборка и запуск всего стенда из репозитория
docker compose --env-file .env up -d --build
# Готовность: все три сервиса healthy
docker compose ps
# Миграции применились к пустому volume
docker compose logs api --tail 12
```
**Ожидаемый вывод:**
```
mtusi-api ... Up (healthy)
mtusi-postgres ... Up (healthy)
mtusi-redis ... Up (healthy)
{"level":"INFO","msg":"postgres connected"}
{"level":"INFO","msg":"running migration","file":"0001_init.sql"}
{"level":"INFO","msg":"redis connected"}
{"level":"INFO","msg":"server started","addr":"0.0.0.0:8080","pid":1}
```
```powershell
curl.exe -s http://localhost:8080/health/ready
curl.exe -s http://localhost:8080/health/live
```
Ожидаемо: `{"status":"ok"}` дважды.
**Что доказывает:** схема (users, chats, chat_members, messages, sessions + PK/FK/UNIQUE/индексы) создаётся версионируемой миграцией `0001_init.sql`, встроенной в бинарник (`go:embed`), к полностью пустому volume. Повторный рестарт не дублирует данные (`IF NOT EXISTS`).
---
## Шаг 1. Регистрация, вход (Basic → Bearer), пароли
```powershell
# Регистрация: password принимается ТОЛЬКО на входе (writeOnly)
Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"alice","display_name":"Alice","password":"Example-only-not-a-real-secret-123"}'
Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"bob","display_name":"Bob","password":"Example-only-not-a-real-secret-12773"}'
```
Ожидаемо: `201` и `User` БЕЗ полей password/password_hash:
```json
{"id":"...","username":"alice","display_name":"Алиса","created_at":"...Z"}
```
```powershell
# Вход: ТОЛЬКО Basic на /auth/sessions; ответ — opaque Bearer-токен
curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions
```
Ожидаемо: `201`:
```json
{"token":"<43 символа base64url>","token_type":"Bearer","expires_at":"...Z","user":{...}}
```
```powershell
# Неверный пароль: 401 + WWW-Authenticate: Basic (не раскрываем существование учётки)
curl.exe -s -i -X POST -u "alice:Wrong-password-999" http://localhost:8080/api/v1/auth/sessions
# Неизвестный пользователь: ТОТ ЖЕ ответ 401 + тот же заголовок
curl.exe -s -i -X POST -u "nosuchuser000:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions
# Пароль в БД: только хэш KDF, plaintext отсутствует
docker compose exec postgres psql -U messenger -d messenger -tAc "SELECT username, left(password_hash, 30) FROM users WHERE username='alice';"
```
Ожидаемо: оба входа → `HTTP/1.1 401` + `Www-Authenticate: Basic realm="messenger", charset="UTF-8"`; в БД строка вида `alice|scrypt$32768$8$1$<salt>$...`.
**Что доказывает:** пароль хешируется библиотечным password KDF (scrypt), не SHA-256 и не plaintext; неверные и неизвестные credentials неразличимы; токен непрозрачный (не username/UUID/JWT), энтропия 256 бит (32 байта `crypto/rand`).
---
## Шаг 2. Защищённый API: Bearer, доступ к чату, пагинация
```powershell
# Сохраняем токен в переменную PowerShell (в Git не попадает)
$s = curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json
$T = $s.token
# Без токена: 401 + WWW-Authenticate: Bearer
curl.exe -s -i http://localhost:8080/api/v1/users/me
# X-User-Id с lab2 ИГНОРИРУЕТСЯ: доступа не даёт
curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: $($s.user.id)"
# Basic на бизнес-endpoint: 401 + WWW-Authenticate: Bearer
curl.exe -s -i http://localhost:8080/api/v1/users/me -u "alice:Example-only-not-a-real-secret-123"
# С токеном: 200
curl.exe -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T"
```
```powershell
# Второй пользователь и чат (вызывающий обязан быть в member_ids)
$b = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"bob\",\"display_name\":\"Боб\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json
$bs = curl.exe -s -X POST -u "bob:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json
$BT = $bs.token
$chat = curl.exe -s -X POST http://localhost:8080/api/v1/chats -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"title\":\"Проект по ВНП\",\"member_ids\":[\"$($s.user.id)\",\"$($b.id)\"]}" | ConvertFrom-Json
# Сообщения и история (created_at, id) по возрастанию
curl.exe -s -X POST http://localhost:8080/api/v1/chats/$($chat.id)/messages -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"text\":\"Привет, Боб!\"}"
curl.exe -s "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=50" -H "Authorization: Bearer $BT"
# Посторонний (carol) получает 404, а не 403: существование чужого чата не раскрывается
$c = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"carol\",\"display_name\":\"Кэрол\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json
$cs = curl.exe -s -X POST -u "carol:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json
curl.exe -s -i http://localhost:8080/api/v1/chats/$($chat.id) -H "Authorization: Bearer $($cs.token)"
```
Ожидаемо: `401` с `Www-Authenticate: Bearer realm="messenger"` в трёх негативных случаях; `200` с токеном; `201` на сообщения; история отсортирована; у carol — `404`.
**Что доказывает:** аутентификация (Bearer → сессия → пользователь) отделена от авторизации (участие в чате); списки содержат только доступные объекты; контракт ошибок соблюдён.
---
## Шаг 3. Persistence: токен живёт только в памяти процесса, рестарт всех хранилищ
```powershell
# Публичный persistence-тест: создаёт данные и сессию, держит токен в памяти,
# вызывает hook, после готовности читает ТЕ ЖЕ данные ТЕМ ЖЕ токеном
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
```
Ожидаемо: `PASS: persistence preserved confirmed data and existing session.`
Ручное подтверждение объёма hook (требование tests/README.md — показать, ЧТО перезапускалось):
```powershell
docker compose ps # ДО: все healthy
scripts\restart.bat # hook: docker compose restart postgres redis api
docker compose ps # ПОСЛЕ: uptime сбросился, все healthy
docker volume ls | Select-String mtusi # volumes НЕ удалены: mtusi_postgres_data, mtusi_redis_data
docker compose logs api --tail 8 # shutdown signal received -> server stopped cleanly -> server started
```
```powershell
# Тот же токен после рестарта: 200 (сессия пережила рестарт, TTL не продлился)
curl.exe -s -o NUL -w "%{http_code}" http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T"
# Logout: 204 без тела; повтор с отозванным токеном: 401
curl.exe -s -o NUL -w "%{http_code}" -X DELETE http://localhost:8080/api/v1/auth/sessions/current -H "Authorization: Bearer $T"
curl.exe -s -i http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T"
```
Ожидаемо: `200`, затем `204`, затем `401` + `Www-Authenticate: Bearer realm="messenger"`.
**Что доказывает:** пользователи, чаты, сообщения и действительные сессии переживают перезапуск API и ОБОИХ хранилищ с сохранёнными volumes; источник истины — PostgreSQL (volume), API stateless.
---
## Шаг 4. Expiry при коротком TTL
```powershell
scripts\expiry.bat
```
Скрипт поднимает API с `SESSION_TTL_SECONDS=2`, прогоняет `student-tests/expiry_checks.py` и возвращает дефолтный TTL. Ожидаемо:
```
[PASS] login 201 with TTL=2
[PASS] fresh token 200
[PASS] expired token -> 401
[PASS] expired WWW-Authenticate Bearer
[PASS] re-login after expiry 201
EXPIRY CHECKS PASSED
```
**Что доказывает:** срок жизни сессии управляется `SESSION_TTL_SECONDS`; истёкший токен → 401 с корректным заголовком; TTL не продлевается рестартом.
---
## Шаг 5. Уровень 4: роль Redis и ошибки зависимостей
```powershell
python student-tests/failover_tests.py --base-url http://localhost:8080
```
Ожидаемо:
```
[PASS] redis down: ready stays 200 (cache optional)
[PASS] redis down: auth via postgres 200
[PASS] redis down: write 201
[PASS] redis down: read 200
[PASS] redis back: ready 200
[PASS] postgres down: ready becomes 503
[PASS] postgres down: protected request 503 (not 200/401)
[PASS] postgres down: anonymous still 401
[PASS] postgres back: ready 200
[PASS] postgres back: same session valid 200
ALL FAILOVER TESTS PASSED
```
**Роль Redis (для защиты):** кэш сессий и кэш истории; источник истины — PostgreSQL. Политика expiry: TTL кэш-ключа сессии = остаток `expires_at`; инвалидация при logout и при истечении. Политика инвалидации истории: версия чата в ключе кэша (Шаг 7). При потере Redis приложение деградирует в SQL (warn в логах), не отказывает и НЕ принимает анонимный запрос как доверенный: при потере Postgres защищённый запрос → 503, аноним → 401.
Дополнительно — гонка регистрации и rollback составной операции (уровень 4):
```powershell
python student-tests/run_tests.py --base-url http://localhost:8080
```
Ключевые строки: `[PASS] race registration: one 201, rest 409` (UNIQUE-ограничение детерминированно решает гонку), `[PASS] rollback: no partial chat` (транзакция создания чата атомарна).
---
## Шаг 6. Уровень 4: план SQL (EXPLAIN ANALYZE BUFFERS, ≥10k сообщений)
```powershell
scripts\explain_demo.bat
Get-Content scripts\explain_plans.md
```
Сев 10 000 сообщений (итого 30 002 в чате), `ANALYZE`, два плана одного keyset-запроса:
| Метрика | С индексом `messages_history_idx` | Без индекса |
|---|---|---|
| План | `Index Scan using messages_history_idx`, Index Cond: `chat_id AND ROW(created_at,id) > ROW(...)` | `Seq Scan on messages` (30 002 строк) + `Sort` |
| Buffers | `shared hit=4 read=1` | `shared hit=383` |
| Execution Time | **0.118 ms** | **4.613 ms** |
**Что доказывает:** индекс `(chat_id, created_at, id)` покрывает запрос пагинации; страница читает только нужные строки, полный scan истории на страницу не выполняется.
---
## Шаг 7. Уровень 5, Трек 1: согласованность кэша истории
```powershell
scripts\cache_demo.bat
Get-Content evidence\cache_track.md
```
Эксперимент переключает `CACHE_MODE` и перезапускает API; четыре фазы:
| Фаза | Смысл | Ключевой результат |
|---|---|---|
| `off` | baseline: кэша нет | `reads=100 sql=132 stampede_sql=32` — 32 конкурентных холодных чтения = 32 SQL (stampede не ограничен) |
| `naive` | кэш БЕЗ инвалидации | `[PASS] naive: stale read OBSERVED` — прогретый кэш вернул страницу БЕЗ только что записанного сообщения (проблема показана) |
| `versioned` | защита: версия чата в ключе + single-flight | `[PASS] read-after-write OK`; `stampede_sql=1` (32 холодных чтения схлопнуты в один SQL); `reads=100 sql=0` (тёплые чтения из кэша) |
| `recovery` | `docker compose restart redis` | сессия валидна (источник истины Postgres), история читается, read-after-write OK, `sql_after_restart=1` (кэш перестроился) |
**Механика защиты (для защиты):**
- Ключ кэша истории: `hist:v<N>:<chat>:<cursor>:<limit>`, где N — счётчик версии чата в Redis.
- На каждый COMMIT записи (`CreateMessage`) выполняется `INCR chatver:<chat>`: старые ключи становятся «мёртвыми», следующее чтение строит ключ с новой версией → cache miss → свежий SELECT. Stale read исключён конструктивно, а не «удалением ключей».
- Single-flight: при конкурирующих miss одного ключа в SQL идёт ровно один запрос, остальные ждут его результат (защита от stampede без глобальной блокировки).
- Контрактное требование «кэш не возвращает устаревшую историю после успешной записи» выполнено в режиме `versioned` и проверено тестом.
---
## Шаг 8. Финальная регрессия (всё зелёное одним прогоном)
```powershell
python tests/smoke.py --base-url http://localhost:8080 # контракт
python student-tests/run_tests.py --base-url http://localhost:8080 # 46 проверок
python student-tests/failover_tests.py --base-url http://localhost:8080
scripts\expiry.bat
scripts\cache_demo.bat
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
```
Ожидаемые финальные строки: `PASS: lab2 public API scenario...`, `ALL STUDENT TESTS PASSED`, `ALL FAILOVER TESTS PASSED`, `EXPIRY CHECKS PASSED`, четыре `PHASE ... DONE`, `PASS: persistence preserved...`.
---
## Артефакты демонстрации
| Артефакт | Что доказывает |
|---|---|
| `docker compose logs api` (migration + shutdown/startup) | миграции с нуля, идемпотентность, graceful shutdown |
| `scripts/explain_plans.md` | индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на 30 002 сообщениях |
| `evidence/cache_track.md` + `evidence/phase_*.txt` | эксперимент трека 5: stale read, stampede, SQL-счётчики до/после, recovery |
| Вывод `tests/resilience.py` + `docker compose ps` до/после + `docker volume ls` | persistence hook действительно перезапустил API и оба хранилища, volumes сохранены |
| Вывод `student-tests/failover_tests.py` | деградация при Redis down; 503 при Postgres down; аноним не доверен |
| Вывод `student-tests/run_tests.py` | контрактные коды/заголовки, гонка регистрации, rollback, пагинация, logout |
| Вывод `scripts/expiry.bat` | expiry при коротком TTL |
| `git status` / `.gitignore` | `.env` и секреты не в Git |
---
## Завершение стенда
```powershell
# Безопасная остановка: volumes сохраняются
docker compose down
# НАМЕРЕННОЕ удаление учебных данных: контейнеры И volumes (данные теряются)
docker compose down -v
```
+24
View File
@@ -0,0 +1,24 @@
# Демонстрация — лабораторная 2 (PostgreSQL, сессии, Redis-кэш)
**Автор, группа:** BVT2304 Shiyan
**Целевая оценка:** 5 (уровни 3 + 4 + Трек 1 «Согласованность кэша»)
**Стенд:** Windows + Docker Desktop, PowerShell 5.1+; все команды выполняются из корня репозитория.
**Секреты:** `.env` создаётся локально из `.env.example` и НЕ коммитится. Токены хранятся в переменных PowerShell (`$T`, `$BT`, `$CT`), в Git не попадают.
Документ проводит защиту по сценарию README lab2: миграции к пустому volume → пользователи/вход/сообщение → persistence с токеном в памяти → expiry → роль Redis и ошибки зависимостей → план SQL → эксперимент трека 5. Каждый шаг: команда → ожидаемый вывод → что это доказывает.
**Примечание по командам:** HTTP-запросы выполняются встроенным cmdlet `Invoke-RestMethod` вместо `curl.exe` — не нужно экранировать кавычки в JSON и проще сохранять поля ответа в переменные. Кодировка при этом **не** определяется автоматически: в Windows PowerShell 5.1 тело `-Body <string>` без `charset` в `Content-Type` кодируется как ISO-8859-1, а начиная с PowerShell 7.4 запросы по умолчанию кодируются в UTF-8. Чтобы демонстрация вела себя одинаково в 5.1 и 7.x, в шаге «Подготовка» задаётся явный `application/json; charset=utf-8` и тело передаётся байтами UTF-8.
---
## Подготовка: один раз в сессии PowerShell
# Запускаем скрипт последовательной остановки
.\scripts\sequential-stop.bat
# Запускаем rolling-update.bat (он стартует load.py в фоне и делает docker compose up -d --build api)
.\scripts\rolling-update.bat
# Запуск тестов смок и мои
.\run-tests.bat
+419
View File
@@ -0,0 +1,419 @@
# Демонстрация лабораторной 4
Запускать из корня репозитория в Windows CMD или PowerShell.
Перед запуском убедись, что учебный стенд поднят и доступен на `http://localhost:8080`.
Все команды ниже — это `.bat`-скрипты из каталога `scripts/` и две проверки health через `curl.exe`.
---
## 1. Health: процесс жив
### Что проверяет
Проверяет, что API отвечает через nginx и что процесс реплики жив.
```bat
curl.exe -s -i http://localhost:8080/health/live
```
Ожидаемо:
```text
HTTP/1.1 200 OK
...
X-Instance-Id: ...
...
{"status":"ok"}
```
---
## 2. Health: готовность принимать трафик
### Что проверяет
Проверяет, что приложение может обслуживать обязательный синхронный путь и что критичные зависимости доступны.
```bat
curl.exe -s -i http://localhost:8080/health/ready
```
Ожидаемо:
```text
HTTP/1.1 200 OK
...
X-Instance-Id: ...
...
{"status":"ok"}
```
---
## 3. Публичный smoke-тест лабы 4
### Что проверяет
Проверяет обязательный публичный контрактный сценарий:
- health;
- регистрацию пользователей;
- вход;
- создание чата;
- сообщения;
- пагинацию;
- ошибки доступа;
- идемпотентность;
- загрузку вложения;
- сообщение с `attachment_ids`;
- скачивание вторым участником;
- запрет доступа постороннему.
```bat
scripts\smoke.bat
```
Ожидаемо:
```text
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
```
---
## 4. Позитивный сценарий вложений
### Что проверяет
Проверяет полный ручной сценарий лабы 4:
1. регистрируются alice, bob и eve;
2. alice и bob создают чат;
3. alice загружает PNG;
4. сервер возвращает метаданные вложения;
5. SHA-256 в метаданных совпадает с SHA-256 исходного файла;
6. alice отправляет сообщение с пустым текстом и `attachment_ids`;
7. bob скачивает байты вложения;
8. скачанные байты имеют тот же SHA-256;
9. eve получает `404` и на метаданные, и на содержимое.
```bat
scripts\manual-attachments.bat
```
Ожидаемо:
```text
ALL MANUAL ATTACHMENT CHECKS PASSED
```
---
## 5. Негативные сценарии вложений
### Что проверяет
Проверяет корректные коды ошибок для опасных и некорректных запросов:
- файл больше 10 MiB → `413`;
- битое изображение → `415`;
- подмена MIME → `415`;
- опасное имя файла → `400`;
- вложение из другого чата → `404`;
- неизвестный `attachment_id` → `404`;
- посторонний пользователь → `404`.
```bat
scripts\negative-attachments.bat
```
Ожидаемо:
```text
ALL NEGATIVE CHECKS PASSED
```
---
## 6. Приватность бакета
### Что проверяет
Проверяет, что прямой доступ к байтам вложения в RustFS без авторизации невозможен.
Это не заменяет ACL приложения, но подтверждает, что приватный бакет действительно приватный.
```bat
scripts\private-bucket-check.bat
```
Ожидаемо:
```text
HTTP/1.1 403 Forbidden
PASS: direct unauthenticated access is not 200
```
---
## 7. Десять одновременных загрузок
### Что проверяет
Проверяет, что стенд выдерживает 10 параллельных загрузок вложений и все они завершаются успешно.
```bat
scripts\concurrent-uploads.bat
```
Ожидаемо:
```text
PASS: 10 concurrent uploads succeeded
```
---
## 8. Пик памяти во время одновременных загрузок
### Что проверяет
Проверяет, что во время 10 одновременных загрузок память API остаётся в пределах лимита контейнера.
Важно: основное доказательство отсутствия неограниченного роста RAM — жёсткий лимит `http.MaxBytesReader` на 10 MiB для одной загрузки. Эксперимент подтверждает, что стенд не деградирует в пределах этого потолка.
```bat
scripts\memory-peak.bat
```
Ожидаемо:
```text
Successful uploads: 10 / 10
Peak API memory during 10 concurrent uploads: <число> MiB (limit 256 MiB per replica)
```
---
## 9. Persistence: подготовка данных
### Что проверяет
Создаёт пользователя, чат, вложение и сообщение с вложением. Состояние сохраняется во временный каталог для проверки после рестарта.
```bat
scripts\persistence-attachment.bat
```
Ожидаемо:
```text
State saved to ...lab4-persistence
attachment=...
message=...
```
---
## 10. Persistence: рестарт стенда
### Что проверяет
Перезапускает контейнеры без удаления volumes.
```bat
scripts\restart-stack.bat
```
Ожидаемо:
```text
Stack is ready.
```
---
## 11. Persistence: проверка сохранности
### Что проверяет
Проверяет после рестарта:
- старый session token работает;
- метаданные вложения доступны;
- SHA-256 метаданных совпадает;
- байты вложения скачиваются;
- скачанный SHA-256 совпадает;
- сообщение с `attachment_ids` присутствует в истории.
```bat
scripts\persistence-verify.bat
```
Ожидаемо:
```text
PASS: attachment metadata survived restart
PASS: attachment bytes survived restart
PASS: message with attachment survived restart
PASS: old session token still works
ALL PERSISTENCE CHECKS PASSED
```
---
## 12. Публичный persistence-тест
### Что проверяет
Запускает публичный тест `tests/resilience.py` в режиме persistence.
Он создаёт данные и сессию, вызывает restart hook, затем проверяет те же данные с прежним токеном. В лабе 4+ также проверяется исходный файл.
```bat
scripts\test-persistence.bat
```
Ожидаемо:
```text
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
```
---
## 13. Failover для вложений
### Что проверяет
Проверяет, что вложение, загруженное через одну реплику, доступно через другую после остановки одной API-реплики.
Это доказывает, что байты не привязаны к локальному диску конкретной реплики, а находятся в общем S3-хранилище.
Скрипт в конце сам восстанавливает остановленную реплику.
```bat
scripts\failover-attachment.bat
```
Ожидаемо:
```text
PASS: attachment bytes available after stopping one replica
```
---
## 14. Публичный failover-тест
### Что проверяет
Запускает публичный тест `tests/resilience.py` в режиме failover.
Он проверяет:
- до отказа наблюдаются минимум две реплики;
- во время остановки одной реплики продолжаются записи;
- неопределённый POST повторяется с тем же `Idempotency-Key`;
- запись восстанавливается не позднее 10 секунд;
- остановленная реплика не обслуживает последние запросы;
- подтверждённые данные не теряются;
- дубли не появляются.
Этот тест проверяет отказ одной API-реплики. Он не доказывает HA для PostgreSQL, nginx или нескольких физических узлов.
```bat
scripts\test-failover.bat
```
Ожидаемо:
```text
{"observed_instances_before": 2, "successful_writes": ..., "failed_attempts": ..., "first_recovery_seconds": ...}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
```
Пример:
```text
{"observed_instances_before": 2, "successful_writes": 72, "failed_attempts": 0, "first_recovery_seconds": 4.591}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
```
---
## 15. Reconcile: компенсация рассинхрона S3 и PostgreSQL
### Что проверяет
Проверяет механизм согласованности для случая, когда объект уже попал в S3, но метаданные не сохранились в PostgreSQL.
Скрипт:
1. создаёт пользователя, чат и вложение;
2. загружает файл, чтобы появились байты в RustFS и метаданные в PostgreSQL;
3. удаляет метаданные из PostgreSQL напрямую, имитируя крах между S3 PUT и DB COMMIT;
4. оставляет объект в S3 осиротевшим;
5. запускает `reconcile` с `grace=0`;
6. проверяет, что reconcile нашёл и удалил осиротевший объект;
7. запускает reconcile повторно и проверяет идемпотентность.
Этот тест меняет данные в учебной БД, поэтому запускается последним.
```bat
scripts\reconcile-demo.bat
```
Ожидаемо в первом прогоне:
```json
{"msg":"reconcile deleted orphan","key":"...","age_seconds":...}
{"msg":"reconcile complete","objects_in_bucket":...,"known_in_db":...,"orphans_deleted":1,"orphans_skipped_young":0,"grace_seconds":0}
```
Ожидаемо во втором прогоне:
```json
{"msg":"reconcile complete","objects_in_bucket":...,"known_in_db":...,"orphans_deleted":0,"orphans_skipped_young":0,"grace_seconds":0}
```
---
## 16. Что доказывает эта демонстрация
Эта последовательность доказывает:
1. API отвечает через health endpoints.
2. Публичный контракт лабы 4 проходит.
3. Вложения загружаются как сырые байты PNG/JPEG.
4. Метаданные вложений хранятся в PostgreSQL.
5. Байты вложений хранятся в приватном RustFS.
6. SHA-256 оригинала сохраняется и совпадает при скачивании.
7. Пустой текст разрешён только при наличии вложений.
8. `attachment_ids` в сообщении проверяются на принадлежность тому же чату.
9. Посторонний пользователь получает `404`.
10. Негативные сценарии возвращают корректные `400`, `413`, `415`, `404`.
11. Прямой доступ к бакету без авторизации запрещён.
12. Десять одновременных загрузок проходят успешно.
13. Память API остаётся в пределах лимита.
14. Данные и байты переживают рестарт стенда.
15. Вложение, загруженное через одну реплику, доступно через другую после остановки первой.
16. Reconcile удаляет осиротевшие объекты и идемпотентен.
---
## 17. Что эта демонстрация не доказывает
Важно честно ограничивать выводы:
1. Публичный smoke не доказывает полную безопасность, все негативные ветки, persistence и HA.
2. `test-failover` доказывает отказ одной API-реплики в docker-стенде, но не несколько физических узлов.
3. PostgreSQL остаётся единой точкой отказа для метаданных.
4. nginx остаётся единой точкой входа.
5. RustFS выбран вместо MinIO/SeaweedFS из-за недоступности их образов в конкретном окружении сборки.
6. RustFS не даёт гранулярные IAM-политики, поэтому основной контроль доступа реализован в приложении через проверку членства в чате.
7. Reconcile запускается вручную через `profiles: [tools]`; в промышленной эксплуатации его нужно запускать по расписанию.
8. Загрузка буферизует файл в памяти в пределах жёсткого лимита 10 MiB. Для файлов произвольной размерности потребовался бы отдельный streaming/multipart-подход, но контракт лабы 4 ограничивает вложение 10 MiB.
+346
View File
@@ -0,0 +1,346 @@
package main
import (
"context"
"encoding/json"
"errors"
"flag"
"log/slog"
"mtusi-messenger/internal/model"
"net/http"
"os"
"os/signal"
"strconv"
"sync/atomic"
"syscall"
"time"
"mtusi-messenger/internal/api"
"mtusi-messenger/internal/store"
"mtusi-messenger/internal/worker"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
)
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func getenvDurationSeconds(key string, def time.Duration) time.Duration {
if v := os.Getenv(key); v != "" {
if n, err := strconv.Atoi(v); err == nil && n >= 0 {
return time.Duration(n) * time.Second
}
}
return def
}
func ensureBucketWithRetry(ctx context.Context, c *store.S3Client, log *slog.Logger) error {
const attempts = 30
const delay = 2 * time.Second
var lastErr error
for i := 1; i <= attempts; i++ {
if ctx.Err() != nil {
return ctx.Err()
}
lastErr = c.EnsureBucket(ctx)
if lastErr == nil {
return nil
}
log.Warn("s3 bootstrap retry", "attempt", i, "max_attempts", attempts, "error", lastErr.Error())
timer := time.NewTimer(delay)
select {
case <-ctx.Done():
timer.Stop()
return ctx.Err()
case <-timer.C:
}
}
return lastErr
}
// runOutboxRelay — публикация намерений из outbox в брокер (лаба 5).
// Закрывает разрыв COMMIT -> publish: всё, что закоммичено, но не опубликовано
// (в т.ч. после краха процесса), будет опубликовано здесь. Повторная публикация
// безопасна: воркер идемпотентен через claim-гард.
func runOutboxRelay(ctx context.Context, st *store.Store, q *store.Queue, log *slog.Logger) {
t := time.NewTicker(500 * time.Millisecond)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
}
for {
msgs, err := st.FetchUnpublishedOutbox(ctx, 50)
if err != nil {
log.Warn("outbox fetch", "error", err.Error())
break
}
if len(msgs) == 0 {
break
}
published := 0
for _, m := range msgs {
var jm model.JobMessage
if err := json.Unmarshal(m.Payload, &jm); err != nil {
log.Error("outbox payload malformed", "error", err.Error())
_ = st.MarkOutboxPublished(ctx, m.ID)
continue
}
if _, err := q.Publish(ctx, jm); err != nil {
log.Warn("outbox publish", "error", err.Error())
break
}
_ = st.MarkOutboxPublished(ctx, m.ID)
published++
}
if published > 0 {
log.Info("outbox relay published", "count", published)
}
if published < len(msgs) {
break // брокер недоступен: повторим на следующем тике
}
}
}
}
func main() {
migrateOnly := flag.Bool("migrate-only", false, "Run migrations and exit")
reconcileMode := flag.Bool("reconcile", false, "Reconcile orphaned S3 objects and exit")
workerMode := flag.Bool("worker", false, "Run attachment processing worker")
flag.Parse()
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
host := getenv("APP_HOST", "0.0.0.0")
port := getenv("APP_PORT", "8080")
addr := host + ":" + port
databaseURL := getenv("DATABASE_URL", "postgres://messenger:messenger_password@localhost:5432/messenger?sslmode=disable")
redisURL := getenv("REDIS_URL", "redis://localhost:6379/0")
sessionStore := getenv("SESSION_STORE", "postgres")
sessionTTL := getenv("SESSION_TTL_SECONDS", "3600")
cacheMode := getenv("CACHE_MODE", "versioned")
s3Endpoint := getenv("S3_ENDPOINT", "localhost:9000")
s3AccessKey := getenv("S3_ACCESS_KEY", "")
s3SecretKey := getenv("S3_SECRET_KEY", "")
s3Bucket := getenv("S3_BUCKET", "messenger")
s3UseSSL := getenv("S3_USE_SSL", "false") == "true"
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// PostgreSQL
poolConfig, err := pgxpool.ParseConfig(databaseURL)
if err != nil {
log.Error("parse database URL", "error", err.Error())
os.Exit(1)
}
poolConfig.MaxConns = 10
poolConfig.MinConns = 2
poolConfig.ConnConfig.ConnectTimeout = 5 * time.Second
poolConfig.MaxConnLifetime = 30 * time.Minute
poolConfig.MaxConnIdleTime = 5 * time.Minute
poolConfig.HealthCheckPeriod = 10 * time.Second
poolConfig.ConnConfig.RuntimeParams["statement_timeout"] = "15000"
pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
if err != nil {
log.Error("connect to postgres", "error", err.Error())
os.Exit(1)
}
defer pool.Close()
if err := pool.Ping(ctx); err != nil {
log.Error("ping postgres", "error", err.Error())
os.Exit(1)
}
log.Info("postgres connected")
// Миграции — только однократный контейнер.
if *migrateOnly {
log.Info("migrate-only mode: applying migrations")
if err := store.RunMigrations(ctx, pool, log); err != nil {
log.Error("migrations failed", "error", err.Error())
os.Exit(1)
}
log.Info("migrations applied successfully, exiting")
os.Exit(0)
}
// Redis: нужен и кэшу, и брокеру. Создаём всегда; деградация кэша не
// отключает очередь (go-redis ленив, реконнект внутри клиента).
rdb := redis.NewClient(mustParseRedisURL(redisURL, log))
if err := rdb.Ping(ctx).Err(); err != nil {
log.Warn("redis ping failed at startup", "error", err.Error())
} else {
log.Info("redis connected")
}
defer rdb.Close()
var cacheRdb *redis.Client
if sessionStore == "redis" {
cacheRdb = rdb
}
// S3
var s3client *store.S3Client
if s3Endpoint != "" && s3AccessKey != "" && s3SecretKey != "" {
s3client, err = store.NewS3Client(s3Endpoint, s3AccessKey, s3SecretKey, s3Bucket, s3UseSSL, log)
if err != nil {
log.Error("init s3 client", "error", err.Error())
os.Exit(1)
}
} else {
log.Warn("S3 credentials not set; attachments unavailable")
}
// Reconcile — однократный режим.
if *reconcileMode {
if s3client == nil {
log.Error("reconcile requires S3 credentials")
os.Exit(1)
}
grace := getenvDurationSeconds("RECONCILE_GRACE_PERIOD_SECONDS", 3600*time.Second)
log.Info("reconcile mode: sweeping orphaned objects", "grace_seconds", int(grace.Seconds()))
recCtx, recCancel := context.WithTimeout(ctx, 120*time.Second)
defer recCancel()
if err := store.RunReconcile(recCtx, pool, s3client, grace, log); err != nil {
log.Error("reconcile failed", "error", err.Error())
os.Exit(1)
}
log.Info("reconcile completed successfully, exiting")
os.Exit(0)
}
st := store.New(pool, cacheRdb, s3client, sessionTTL, cacheMode, log)
queue := store.NewQueue(rdb, log)
// ─────────── WORKER MODE ───────────
if *workerMode {
if s3client == nil {
log.Error("worker requires S3 credentials")
os.Exit(1)
}
// LAB 5: воркер не должен умирать из-за временной недоступности S3 на старте.
// Одна быстрая попытка bootstrap; при неудаче продолжаем — каждое задание
// само получит transient-ошибку и уйдёт в retry с backoff.
pingCtx, pingCancel := context.WithTimeout(ctx, 5*time.Second)
err := s3client.EnsureBucket(pingCtx)
pingCancel()
if err != nil {
log.Warn("s3 not ready at worker start; continuing, jobs will retry", "error", err.Error())
} else {
log.Info("s3 ready", "endpoint", s3Endpoint, "bucket", s3Bucket)
}
w := worker.New(st, queue, log)
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
errCh := make(chan error, 1)
go func() { errCh <- w.Run(ctx) }()
select {
case err := <-errCh:
if err != nil {
log.Error("worker failed", "error", err.Error())
os.Exit(1)
}
case sig := <-stop:
log.Info("worker shutdown signal", "signal", sig.String())
cancel()
<-errCh
}
log.Info("worker stopped cleanly")
return
}
// ─────────── API MODE ───────────
log.Info("migrations already applied by migrate service, starting server")
if s3client != nil {
bootCtx, bootCancel := context.WithTimeout(ctx, 90*time.Second)
err = ensureBucketWithRetry(bootCtx, s3client, log)
bootCancel()
if err != nil {
log.Error("ensure s3 bucket", "error", err.Error())
os.Exit(1)
}
log.Info("s3 ready", "endpoint", s3Endpoint, "bucket", s3Bucket)
}
// Outbox relay: публикация намерений в брокер.
go runOutboxRelay(ctx, st, queue, log)
ready := &atomic.Bool{}
ready.Store(true)
var instanceID string
if v := getenv("INSTANCE_ID", ""); v != "" {
instanceID = v
} else {
hostname, _ := os.Hostname()
prefix := hostname
if len(prefix) > 12 {
prefix = prefix[:12]
}
if prefix == "" {
prefix = "local"
}
instanceID = prefix + "-" + uuid.NewString()[:8]
}
log.Info("instance identity", "instance_id", instanceID)
srv := api.NewServer(st, log, ready, instanceID)
httpSrv := &http.Server{
Addr: addr,
Handler: srv.Handler(),
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 60 * time.Second,
IdleTimeout: 60 * time.Second,
}
errCh := make(chan error, 1)
go func() { errCh <- httpSrv.ListenAndServe() }()
log.Info("server started", "addr", addr, "pid", os.Getpid())
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
select {
case err := <-errCh:
if err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Error("server failed", "error", err.Error())
os.Exit(1)
}
case sig := <-stop:
log.Info("shutdown signal received", "signal", sig.String())
ready.Store(false)
sctx, scancel := context.WithTimeout(context.Background(), 8*time.Second)
defer scancel()
if err := httpSrv.Shutdown(sctx); err != nil {
log.Warn("graceful shutdown exceeded budget, closing", "error", err.Error())
_ = httpSrv.Close()
}
cancel()
log.Info("server stopped cleanly")
}
}
func mustParseRedisURL(redisURL string, log *slog.Logger) *redis.Options {
opts, err := redis.ParseURL(redisURL)
if err != nil {
log.Error("parse redis URL", "error", err.Error())
os.Exit(1)
}
return opts
}
+33
View File
@@ -0,0 +1,33 @@
module mtusi-messenger
go 1.22
require (
github.com/chai2010/webp v1.4.0
github.com/disintegration/imaging v1.6.2
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.5.5
github.com/minio/minio-go/v7 v7.0.76
github.com/redis/go-redis/v9 v9.5.1
golang.org/x/crypto v0.26.0
)
require (
github.com/cespare/xxhash/v2 v2.2.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/go-ini/ini v1.67.0 // indirect
github.com/goccy/go-json v0.10.3 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
github.com/jackc/puddle/v2 v2.2.1 // indirect
github.com/klauspost/compress v1.17.9 // indirect
github.com/klauspost/cpuid/v2 v2.2.8 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/rs/xid v1.6.0 // indirect
golang.org/x/image v0.0.0-20211028202545-6944b10bf410 // indirect
golang.org/x/net v0.28.0 // indirect
golang.org/x/sync v0.8.0 // indirect
golang.org/x/sys v0.24.0 // indirect
golang.org/x/text v0.17.0 // indirect
)
+72
View File
@@ -0,0 +1,72 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/chai2010/webp v1.4.0 h1:6DA2pkkRUPnbOHvvsmGI3He1hBKf/bkRlniAiSGuEko=
github.com/chai2010/webp v1.4.0/go.mod h1:0XVwvZWdjjdxpUEIf7b9g9VkHFnInUSYujwqTLEuldU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw=
github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v7 v7.0.76 h1:9nxHH2XDai61cT/EFhyIw/wW4vJfpPNvl7lSFpRt+Ng=
github.com/minio/minio-go/v7 v7.0.76/go.mod h1:AVM3IUN6WwKzmwBxVdjzhH8xq+f57JSbbvzqvUzR6eg=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8=
github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.0.0-20211028202545-6944b10bf410 h1:hTftEOvwiOq2+O8k2D5/Q7COC7k5Qcrgc2TFURJYnvQ=
golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE=
golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+561
View File
@@ -0,0 +1,561 @@
package api
import (
"bytes"
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"mime"
"net/http"
"strconv"
"github.com/google/uuid"
"mtusi-messenger/internal/apperr"
"mtusi-messenger/internal/model"
"mtusi-messenger/internal/store"
)
// ───────────────────────────── health ─────────────────────────────
func (s *Server) healthLive(w http.ResponseWriter, r *http.Request) {
writeJSON(w, r, http.StatusOK, model.Health{Status: "ok"})
}
func (s *Server) healthReady(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
if !s.ready.Load() {
apperr.Write(w, id, apperr.Unavailable("service is shutting down"))
return
}
if err := s.store.Ping(r.Context()); err != nil {
apperr.Write(w, id, apperr.Unavailable("database unavailable"))
return
}
writeJSON(w, r, http.StatusOK, model.Health{Status: "ok"})
}
// ───────────────────────────── users ─────────────────────────────
func (s *Server) usersRoute(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
methodNotAllowed(w, r)
return
}
id := requestID(r)
var req model.CreateUserReq
if aerr := decodeJSON(w, r, &req); aerr != nil {
apperr.Write(w, id, aerr)
return
}
if !usernameRe.MatchString(req.Username) {
apperr.Write(w, id, apperr.InvalidRequest("username must match ^[a-z0-9_]{3,32}$"))
return
}
if !validText(req.DisplayName, 100) {
apperr.Write(w, id, apperr.InvalidRequest("display_name must be 1..100 non-space code points"))
return
}
if !validPassword(req.Password) {
apperr.Write(w, id, apperr.InvalidRequest("password must be 12..128 non-space code points"))
return
}
u, err := s.store.CreateUser(r.Context(), req.Username, req.DisplayName, req.Password)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusCreated, u)
}
func (s *Server) me(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
methodNotAllowed(w, r)
return
}
writeJSON(w, r, http.StatusOK, currentUser(r))
}
// ───────────────────────────── sessions ─────────────────────────────
func (s *Server) createSession(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
methodNotAllowed(w, r)
return
}
id := requestID(r)
creds := currentCreds(r)
user, err := s.store.UserByCredentials(r.Context(), creds.Username, creds.Password)
if err != nil {
w.Header().Set("WWW-Authenticate", wwwBasic)
apperr.Write(w, id, apperr.Unauthorized("invalid credentials"))
return
}
token, expiresAt, err := s.store.CreateSession(r.Context(), user.ID)
if err != nil {
apperr.Write(w, id, apperr.Internal("internal error"))
return
}
writeJSON(w, r, http.StatusCreated, model.SessionResponse{
Token: token,
TokenType: "Bearer",
ExpiresAt: model.Timestamp{Time: expiresAt},
User: *user,
})
}
func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
methodNotAllowed(w, r)
return
}
if err := s.store.RevokeSession(r.Context(), currentToken(r)); err != nil {
apperr.Write(w, requestID(r), apperr.Unavailable("logout not confirmed, please retry"))
return
}
writeNoContent(w, r)
}
// ───────────────────────────── chats ─────────────────────────────
func (s *Server) chatsRoute(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost:
s.createChat(w, r)
case http.MethodGet:
s.listChats(w, r)
default:
methodNotAllowed(w, r)
}
}
func (s *Server) createChat(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
var req model.CreateChatReq
if aerr := decodeJSON(w, r, &req); aerr != nil {
apperr.Write(w, id, aerr)
return
}
if !validText(req.Title, 100) {
apperr.Write(w, id, apperr.InvalidRequest("title must be 1..100 non-space code points"))
return
}
if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 {
apperr.Write(w, id, apperr.InvalidRequest("member_ids must contain 1..100 items"))
return
}
seen := make(map[string]bool, len(req.MemberIDs))
for _, raw := range req.MemberIDs {
uid, err := parseUUID(raw)
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("member_ids must be UUID strings"))
return
}
if seen[uid] {
apperr.Write(w, id, apperr.InvalidRequest("duplicate member_id"))
return
}
seen[uid] = true
}
caller := currentUser(r)
if !seen[caller.ID] {
apperr.Write(w, id, apperr.InvalidRequest("creator must be included in member_ids"))
return
}
chat, err := s.store.CreateChat(r.Context(), req.Title, req.MemberIDs, caller.ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusCreated, chat)
}
func (s *Server) listChats(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
caller := currentUser(r)
limit, cur, aerr := pagingParams(r, caller.ID)
if aerr != nil {
apperr.Write(w, id, aerr)
return
}
items, more, err := s.store.ListChats(r.Context(), caller.ID, limit, cur)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
page := model.Page[*model.Chat]{Items: items}
if more && len(items) > 0 {
last := items[len(items)-1]
encoded := store.EncodeCursor(store.Cursor{Scope: caller.ID, TS: last.CreatedAt.Time, ID: last.ID})
page.NextCursor = &encoded
}
writeJSON(w, r, http.StatusOK, page)
}
func (s *Server) chatRoute(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
methodNotAllowed(w, r)
return
}
id := requestID(r)
chatID, err := parseUUID(r.PathValue("chat_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID"))
return
}
chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusOK, chat)
}
// ───────────────────────────── messages ─────────────────────────────
func (s *Server) messagesRoute(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodPost:
s.createMessage(w, r)
case http.MethodGet:
s.listMessages(w, r)
default:
methodNotAllowed(w, r)
}
}
func (s *Server) createMessage(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
chatID, err := parseUUID(r.PathValue("chat_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID"))
return
}
chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
idempotencyKey := r.Header.Get("Idempotency-Key")
if idempotencyKey == "" {
apperr.Write(w, id, apperr.InvalidRequest("Idempotency-Key header is required"))
return
}
var req model.CreateMessageReq
if aerr := decodeJSON(w, r, &req); aerr != nil {
apperr.Write(w, id, aerr)
return
}
if req.AttachmentIDs == nil {
req.AttachmentIDs = []string{}
}
if len(req.AttachmentIDs) == 0 {
if !validText(req.Text, 4000) {
apperr.Write(w, id, apperr.InvalidRequest("text must be 1..4000 non-space code points or provide attachment_ids"))
return
}
} else {
if len(req.AttachmentIDs) > 10 {
apperr.Write(w, id, apperr.InvalidRequest("attachment_ids must contain at most 10 items"))
return
}
seen := make(map[string]bool, len(req.AttachmentIDs))
for _, raw := range req.AttachmentIDs {
aid, err := parseUUID(raw)
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("attachment_ids must be UUID strings"))
return
}
if seen[aid] {
apperr.Write(w, id, apperr.InvalidRequest("duplicate attachment_id"))
return
}
seen[aid] = true
}
if req.Text != "" && !validText(req.Text, 4000) {
apperr.Write(w, id, apperr.InvalidRequest("text must be 1..4000 non-space code points"))
return
}
if err := s.store.ValidateAttachmentsForChat(r.Context(), chat.ID, req.AttachmentIDs); err != nil {
s.writeStoreErr(w, r, err)
return
}
}
msg, err := s.store.CreateMessage(r.Context(), chat.ID, currentUser(r).ID, req.Text, req.AttachmentIDs, idempotencyKey)
if err != nil {
if errors.Is(err, store.ErrIdempotencyConflict) {
apperr.Write(w, id, apperr.Conflict("idempotency key mismatch"))
return
}
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusCreated, msg)
}
func (s *Server) listMessages(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
chatID, err := parseUUID(r.PathValue("chat_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID"))
return
}
chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
limit, cur, aerr := pagingParams(r, chat.ID)
if aerr != nil {
apperr.Write(w, id, aerr)
return
}
items, more, err := s.store.ListMessages(r.Context(), chat.ID, limit, cur)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
page := model.Page[*model.Message]{Items: items}
if more && len(items) > 0 {
last := items[len(items)-1]
encoded := store.EncodeCursor(store.Cursor{Scope: chat.ID, TS: last.CreatedAt.Time, ID: last.ID})
page.NextCursor = &encoded
}
writeJSON(w, r, http.StatusOK, page)
}
// ───────────────────────────── attachments (lab5) ─────────────────────────────
func (s *Server) attachmentsRoute(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
s.uploadAttachment(w, r)
return
}
methodNotAllowed(w, r)
}
func (s *Server) attachmentRoute(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodGet {
s.getAttachment(w, r)
return
}
methodNotAllowed(w, r)
}
func (s *Server) attachmentContentRoute(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodGet {
s.downloadAttachment(w, r)
return
}
methodNotAllowed(w, r)
}
// uploadAttachment — POST /chats/{chat_id}/attachments?filename=...
// LAB 5: сырые байты принимаются в staging, намерение обработать фиксируется
// транзакцией (attachment queued + job + outbox), ответ — 202 queued.
func (s *Server) uploadAttachment(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
chatID, err := parseUUID(r.PathValue("chat_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID"))
return
}
filename := r.URL.Query().Get("filename")
if !validFilename(filename) {
apperr.Write(w, id, apperr.InvalidRequest("filename must be 1..255 code points without '/', '\\', NUL or control chars"))
return
}
chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
media, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
if media != "image/png" && media != "image/jpeg" {
apperr.Write(w, id, apperr.UnsupportedMedia("Content-Type must be image/png or image/jpeg"))
return
}
r.Body = http.MaxBytesReader(w, r.Body, maxUploadBytes)
buf := &bytes.Buffer{}
hasher := sha256.New()
n, err := io.Copy(io.MultiWriter(buf, hasher), r.Body)
if err != nil {
var maxErr *http.MaxBytesError
if errors.As(err, &maxErr) {
apperr.Write(w, id, apperr.PayloadTooLarge("file exceeds 10 MiB limit"))
return
}
apperr.Write(w, id, apperr.InvalidRequest("unable to read request body"))
return
}
if n == 0 {
apperr.Write(w, id, apperr.InvalidRequest("empty file"))
return
}
data := buf.Bytes()
contentType, width, height, serr := sniffImage(data)
if serr != nil {
apperr.Write(w, id, apperr.UnsupportedMedia("file is not a valid PNG or JPEG image"))
return
}
if contentType != media {
apperr.Write(w, id, apperr.UnsupportedMedia("declared Content-Type does not match file content"))
return
}
if int64(width)*int64(height) > maxDecodedPixels {
apperr.Write(w, id, apperr.PayloadTooLarge("image exceeds 40 megapixels"))
return
}
// LAB 5 (ревью): целостность файла проверяется ДО приёма задания.
// DecodeConfig читает только заголовок, поэтому усечённый PNG иначе
// ушёл бы в очередь и упал уже в worker. Ресурсные лимиты сохранены.
if ierr := validateImageIntegrity(data, contentType, width, height); ierr != nil {
apperr.Write(w, id, apperr.UnsupportedMedia("file is corrupted or truncated"))
return
}
attID := uuid.NewString()
stagingKey := store.StagingKey(chat.ID, attID)
finalKey := store.VariantKey(chat.ID, attID, "original")
if err := s.store.PutObject(r.Context(), stagingKey, data, contentType); err != nil {
apperr.Write(w, id, apperr.Unavailable("object storage unavailable"))
return
}
now := model.NowTS()
att := &model.Attachment{
ID: attID,
ChatID: chat.ID,
OwnerID: currentUser(r).ID,
Filename: filename,
ContentType: contentType,
SizeBytes: n,
SHA256: hex.EncodeToString(hasher.Sum(nil)),
Status: model.StatusQueued,
Variants: []model.Variant{},
ErrorCode: nil,
CreatedAt: now,
UpdatedAt: now,
S3Key: finalKey,
}
created, err := s.store.CreateQueuedAttachment(r.Context(), att)
if err != nil {
_ = s.store.DeleteObject(r.Context(), stagingKey)
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusAccepted, created)
}
// getAttachment — GET /attachments/{id}: метаданные со статусом и вариантами.
func (s *Server) getAttachment(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
attID, err := parseUUID(r.PathValue("attachment_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("attachment_id must be a UUID"))
return
}
att, err := s.store.GetAttachmentForUser(r.Context(), attID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
writeJSON(w, r, http.StatusOK, att)
}
// downloadAttachment — GET /attachments/{id}/content[?variant=...].
// LAB 5: байты отдаются только в status=ready; до готовности — 409.
func (s *Server) downloadAttachment(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
variant := r.URL.Query().Get("variant")
if variant == "" {
variant = "original"
}
switch variant {
case "original", "thumbnail", "crop", "optimized":
default:
apperr.Write(w, id, apperr.NotFound("variant not found"))
return
}
attID, err := parseUUID(r.PathValue("attachment_id"))
if err != nil {
apperr.Write(w, id, apperr.InvalidRequest("attachment_id must be a UUID"))
return
}
att, err := s.store.GetAttachmentForUser(r.Context(), attID, currentUser(r).ID)
if err != nil {
s.writeStoreErr(w, r, err)
return
}
if att.Status != model.StatusReady {
apperr.Write(w, id, apperr.Conflict("attachment is not ready yet"))
return
}
key := att.S3Key
contentType := att.ContentType
if variant != "original" {
var found *model.Variant
for i := range att.Variants {
if att.Variants[i].Name == variant {
found = &att.Variants[i]
break
}
}
if found == nil {
apperr.Write(w, id, apperr.NotFound("variant not found"))
return
}
key = store.VariantKey(att.ChatID, att.ID, variant)
contentType = found.ContentType
}
data, err := s.store.GetObject(r.Context(), key)
if err != nil {
apperr.Write(w, id, apperr.Unavailable("object storage unavailable"))
return
}
w.Header().Set("Content-Type", contentType)
w.Header().Set("Content-Length", strconv.FormatInt(int64(len(data)), 10))
w.Header().Set("X-Request-Id", id)
w.WriteHeader(http.StatusOK)
_, _ = w.Write(data)
}
// ───────────────────────────── общее ─────────────────────────────
func (s *Server) notFound(w http.ResponseWriter, r *http.Request) {
apperr.Write(w, requestID(r), apperr.NotFound("route not found"))
}
// writeStoreErr — маппинг sentinel-ошибок store в HTTP-статусы контракта.
func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error) {
id := requestID(r)
switch {
case errors.Is(err, store.ErrNotFound):
apperr.Write(w, id, apperr.NotFound("object not found or not accessible"))
case errors.Is(err, store.ErrBadMembers):
apperr.Write(w, id, apperr.InvalidRequest("unknown member_id"))
case errors.Is(err, store.ErrUsernameTaken):
apperr.Write(w, id, apperr.Conflict("username is already taken"))
case store.IsUnavailable(err):
apperr.Write(w, id, apperr.Unavailable("database unavailable"))
default:
apperr.Write(w, id, apperr.Internal("internal error"))
}
}
+208
View File
@@ -0,0 +1,208 @@
// package api, helpers.go — пограничный контроль входа (перенос из lab1 + разбор Authorization + валидация вложений lab4).
package api
import (
"bytes"
"encoding/base64"
"encoding/json"
"errors"
"image"
_ "image/jpeg" // регистрация декодеров для image.DecodeConfig
_ "image/png"
"mime"
"net/http"
"regexp"
"strconv"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"mtusi-messenger/internal/apperr"
"mtusi-messenger/internal/store"
)
const maxBodyBytes = 1 << 20
// ─────────────── Лимиты вложений (lab4) ───────────────
const (
// Ровно 10 MiB, как в контракте: 10 * 1024 * 1024 = 10 485 760 байт.
// Это ЖЁСТКИЙ потолок: одна загрузка не может занять больше, даже если
// клиент шлёт бесконечный поток (см. http.MaxBytesReader в uploadAttachment).
maxUploadBytes = 10 << 20
// Не более 40 миллионов декодированных пикселей (ширина * высота).
maxDecodedPixels = 40_000_000
)
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
// parseUUID — канонический UUID или ошибка (из lab1).
func parseUUID(s string) (string, error) {
u, err := uuid.Parse(s)
if err != nil || u.String() != s {
return "", errors.New("invalid uuid")
}
return u.String(), nil
}
func runeLen(s string) int { return utf8.RuneCountInString(s) }
// validText — обязательная строка 1..max code points, не только пробелы (из lab1).
func validText(s string, max int) bool {
n := runeLen(s)
return n >= 1 && n <= max && strings.TrimSpace(s) != ""
}
// validPassword — контракт lab2: 12–128 code points, UTF-8, двоеточие допустимо.
func validPassword(s string) bool {
n := runeLen(s)
return n >= 12 && n <= 128 && strings.TrimSpace(s) != ""
}
// validFilename — отображаемое имя файла (1..255 code points), lab4.
// Отклоняем '/', '\', NUL и управляющие символы. Имя используется ТОЛЬКО для
// отображения и никогда как путь или ключ S3 — ключ генерирует сервер.
func validFilename(s string) bool {
n := runeLen(s)
if n < 1 || n > 255 {
return false
}
if strings.ContainsAny(s, "/\\\x00") {
return false
}
for _, r := range s {
if r < 0x20 || r == 0x7f { // управляющие символы
return false
}
}
return true
}
// sniffImage — определяет фактический тип изображения по СОДЕРЖИМОМУ и его
// геометрические размеры БЕЗ полного декодирования пикселей.
// Возвращает (contentType, width, height, error).
// Контракт: MIME проверяется по содержимому; лимит пикселей применяется до
// полной распаковки. Декодеры берут только заголовок, поэтому память ограничена.
func sniffImage(data []byte) (string, int, int, error) {
ct := http.DetectContentType(data)
if ct != "image/png" && ct != "image/jpeg" {
return "", 0, 0, errors.New("unsupported image type")
}
cfg, format, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil {
return "", 0, 0, err // повреждённое/неполное изображение
}
// Проверяем, что формат соответствует MIME (подмена типа).
expectedFormat := ""
if ct == "image/png" {
expectedFormat = "png"
} else if ct == "image/jpeg" {
expectedFormat = "jpeg"
}
if format != expectedFormat {
return "", 0, 0, errors.New("declared Content-Type does not match file content")
}
return ct, cfg.Width, cfg.Height, nil
}
// ─────────────── Разбор Authorization (из lab2, без изменений) ───────────────
type loginCreds struct {
Username string
Password string
}
func parseBasicHeader(r *http.Request) (loginCreds, bool) {
h := r.Header.Get("Authorization")
const prefix = "Basic "
if !strings.HasPrefix(h, prefix) {
return loginCreds{}, false
}
raw, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(h, prefix))
if err != nil {
return loginCreds{}, false
}
u, p, found := strings.Cut(string(raw), ":")
if !found {
return loginCreds{}, false
}
return loginCreds{Username: u, Password: p}, true
}
func parseBearerHeader(r *http.Request) (string, bool) {
h := r.Header.Get("Authorization")
const prefix = "Bearer "
if !strings.HasPrefix(h, prefix) {
return "", false
}
t := strings.TrimPrefix(h, prefix)
if t == "" {
return "", false
}
return t, true
}
// decodeJSON — конвейер 415 -> 413 -> 400 (из lab1, без изменений).
// ВНИМАНИЕ: используется только для JSON-эндпоинтов. Загрузка вложений идёт
// сырыми байтами мимо этой функции (см. uploadAttachment).
func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) *apperr.AppError {
media, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
if media != "application/json" {
return apperr.UnsupportedMedia("Content-Type must be application/json")
}
r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes)
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
var maxErr *http.MaxBytesError
if errors.As(err, &maxErr) {
return apperr.PayloadTooLarge("request body too large")
}
return apperr.InvalidRequest("malformed JSON body")
}
if dec.More() {
return apperr.InvalidRequest("multiple JSON documents in body")
}
return nil
}
// pagingParams — limit 1..100 (default 50) + курсор с проверкой scope (из lab1).
func pagingParams(r *http.Request, scope string) (int, *store.Cursor, *apperr.AppError) {
limit := 50
if v := r.URL.Query().Get("limit"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 1 || n > 100 {
return 0, nil, apperr.InvalidRequest("limit must be an integer in 1..100")
}
limit = n
}
var cur *store.Cursor
if v := r.URL.Query().Get("cursor"); v != "" {
c, err := store.DecodeCursor(v)
if err != nil {
return 0, nil, apperr.InvalidRequest("invalid cursor")
}
if c.Scope != scope {
return 0, nil, apperr.InvalidRequest("cursor does not belong to this resource")
}
cur = &c
}
return limit, cur, nil
}
// writeJSON — единая точка успешного ответа (из lab1).
func writeJSON(w http.ResponseWriter, r *http.Request, status int, payload any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Request-Id", requestID(r))
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(payload)
}
// writeNoContent — 204 без тела (logout). Тела нет, но заголовки контракта остаются.
func writeNoContent(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Request-Id", requestID(r))
w.WriteHeader(http.StatusNoContent)
}
func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
apperr.Write(w, requestID(r), apperr.New(http.StatusMethodNotAllowed, apperr.CodeInvalidRequest, "method not allowed"))
}
+196
View File
@@ -0,0 +1,196 @@
// Package api, image_integrity.go — проверка ЦЕЛОСТНОСТИ изображения до приёма
// задания (лаба 5, замечание ревью).
//
// Почему отдельный шаг: image.DecodeConfig читает только заголовок, поэтому
// усечённый PNG с валидным IHDR проходил приём и падал уже в worker. Контракт
// требует 415 на приёме для заведомо повреждённых файлов.
//
// Ресурсные ограничения сохранены:
// - размер тела ограничен http.MaxBytesReader (10 MiB) ДО чтения;
// - габариты и потолок 40 Мп проверены ДО вызова этой функции;
// - PNG проверяется структурно (CRC32 чанков + полный inflate IDAT в discard),
// без выделения пиксельного буфера;
// - JPEG декодируется полностью, но не более одной проверки одновременно
// на реплику (семафор), т.к. пиксельный буфер JPEG заметно меньше RGBA.
package api
import (
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"fmt"
"hash/crc32"
"image/jpeg"
"io"
)
var pngSignature = []byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}
// jpegDecodeGate — не более одной полной JPEG-проверки на реплику.
var jpegDecodeGate = make(chan struct{}, 1)
// validateImageIntegrity возвращает ошибку, если файл повреждён/усечён.
// Вызывается после sniffImage, сверки MIME и проверки потолка пикселей.
func validateImageIntegrity(data []byte, contentType string, width, height int) error {
switch contentType {
case "image/png":
return validatePNGIntegrity(data, width, height)
case "image/jpeg":
return validateJPEGIntegrity(data)
default:
return errors.New("unsupported image type")
}
}
// validatePNGIntegrity — обход чанков с проверкой CRC, обязательный IEND и
// полная распаковка IDAT. Пиксели не материализуются.
func validatePNGIntegrity(data []byte, width, height int) error {
// 8 байт сигнатуры + 25 байт минимального IHDR-чанка.
if len(data) < len(pngSignature)+25 || !bytes.HasPrefix(data, pngSignature) {
return errors.New("png: missing signature or IHDR")
}
pos := len(pngSignature)
var idat bytes.Buffer
var sawIEND bool
var bitDepth, colorType, interlace byte
for pos+12 <= len(data) {
length := int(binary.BigEndian.Uint32(data[pos : pos+4]))
if length < 0 || pos+12+length > len(data) {
return errors.New("png: truncated chunk")
}
typ := data[pos+4 : pos+8]
payload := data[pos+8 : pos+8+length]
wantCRC := binary.BigEndian.Uint32(data[pos+8+length : pos+12+length])
h := crc32.NewIEEE()
_, _ = h.Write(typ)
_, _ = h.Write(payload)
if h.Sum32() != wantCRC {
return fmt.Errorf("png: bad CRC in %s chunk", typ)
}
switch string(typ) {
case "IHDR":
if length != 13 {
return errors.New("png: bad IHDR length")
}
bitDepth = payload[8]
colorType = payload[9]
interlace = payload[12]
case "IDAT":
idat.Write(payload)
case "IEND":
sawIEND = true
}
pos += 12 + length
if sawIEND {
break
}
}
if !sawIEND {
return errors.New("png: missing IEND (truncated file)")
}
if idat.Len() == 0 {
return errors.New("png: no IDAT data")
}
zr, err := zlib.NewReader(bytes.NewReader(idat.Bytes()))
if err != nil {
return fmt.Errorf("png: zlib header: %w", err)
}
defer zr.Close()
expected, err := expectedRawPNGSize(width, height, int(bitDepth), int(colorType), int(interlace))
if err != nil {
return err
}
// limit+1 позволяет отличить «ровно ожидаемый объём» от «раздулось больше».
// Если поток ровно expected, zlib дочитывается до EOF и проверяет adler32.
n, err := io.Copy(io.Discard, io.LimitReader(zr, expected+1))
if err != nil {
return fmt.Errorf("png: inflate IDAT: %w", err)
}
if n != expected {
return fmt.Errorf("png: inflated %d bytes, expected %d (truncated or malformed)", n, expected)
}
return nil
}
// expectedRawPNGSize — точный объём распакованных scanline-данных PNG,
// включая фильтр-байт каждой строки и все проходы Adam7 при interlace=1.
func expectedRawPNGSize(width, height, bitDepth, colorType, interlace int) (int64, error) {
var channels int
switch colorType {
case 0: // grayscale
channels = 1
case 2: // truecolor
channels = 3
case 3: // palette
channels = 1
case 4: // grayscale + alpha
channels = 2
case 6: // truecolor + alpha
channels = 4
default:
return 0, fmt.Errorf("png: unknown color type %d", colorType)
}
if width <= 0 || height <= 0 {
return 0, errors.New("png: non-positive dimensions")
}
rowBytes := func(w int) int64 {
bits := int64(w) * int64(channels) * int64(bitDepth)
return 1 + (bits+7)/8 // 1 фильтр-байт + округление вверх до байта
}
if interlace == 0 {
return int64(height) * rowBytes(width), nil
}
// Adam7: семь проходов (xStart, yStart, xStep, yStep).
passes := [7][4]int{
{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4},
{0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2},
}
var total int64
for _, p := range passes {
pw, ph := 0, 0
if width > p[0] {
pw = (width - p[0] + p[2] - 1) / p[2]
}
if height > p[1] {
ph = (height - p[1] + p[3] - 1) / p[3]
}
if pw > 0 && ph > 0 {
total += int64(ph) * rowBytes(pw)
}
}
if total == 0 {
return 0, errors.New("png: empty interlaced image")
}
return total, nil
}
// validateJPEGIntegrity — маркеры SOI/EOI плюс полное декодирование под гейтом.
func validateJPEGIntegrity(data []byte) error {
if len(data) < 4 || data[0] != 0xFF || data[1] != 0xD8 {
return errors.New("jpeg: missing SOI marker")
}
if !bytes.HasSuffix(data, []byte{0xFF, 0xD9}) {
return errors.New("jpeg: missing EOI marker (truncated file)")
}
jpegDecodeGate <- struct{}{}
defer func() { <-jpegDecodeGate }()
if _, err := jpeg.Decode(bytes.NewReader(data)); err != nil {
return fmt.Errorf("jpeg: decode: %w", err)
}
return nil
}
+145
View File
@@ -0,0 +1,145 @@
package api
import (
"context"
"log/slog"
"net/http"
"strings"
"time"
"mtusi-messenger/internal/apperr"
"mtusi-messenger/internal/model"
"mtusi-messenger/internal/store"
"github.com/google/uuid"
)
type ctxKey int
const (
ctxRequestID ctxKey = iota
ctxUser
ctxToken
ctxCreds
)
const (
wwwBearer = `Bearer realm="messenger"`
wwwBasic = `Basic realm="messenger", charset="UTF-8"`
)
// ─────────── Охранник 1: номерок (из lab1) ───────────
func requestIDMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-Id")
if id == "" {
id = uuid.NewString()
}
w.Header().Set("X-Request-Id", id)
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxRequestID, id)))
})
}
func requestID(r *http.Request) string {
if id, ok := r.Context().Value(ctxRequestID).(string); ok && id != "" {
return id
}
return "unknown"
}
// ─────────── Охранник 2: журнал без тел (из lab1) ───────────
type statusWriter struct {
http.ResponseWriter
status int
}
func (s *statusWriter) WriteHeader(code int) {
s.status = code
s.ResponseWriter.WriteHeader(code)
}
func loggingMiddleware(log *slog.Logger, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
sw := &statusWriter{ResponseWriter: w, status: http.StatusOK}
next.ServeHTTP(sw, r)
log.Info("http",
"method", r.Method,
"path", r.URL.Path,
"status", sw.status,
"dur_ms", time.Since(start).Milliseconds(),
"request_id", requestID(r),
)
})
}
// ─────────── Охранник 3: выключатель паник (из lab1) ───────────
func recoverMiddleware(log *slog.Logger, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
log.Error("panic recovered", "path", r.URL.Path, "request_id", requestID(r))
apperr.Write(w, requestID(r), apperr.Internal("internal error"))
}
}()
next.ServeHTTP(w, r)
})
}
// ─────────── Охранник 4: Идентификатор реплики (Lab 3) ───────────
func instanceIDMiddleware(instanceID string, 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)
})
}
// ─────────── Пропускной пункт lab2: Bearer ───────────
func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
h := r.Header.Get("Authorization")
if strings.HasPrefix(h, "Basic ") {
w.Header().Set("WWW-Authenticate", wwwBearer)
apperr.Write(w, id, apperr.Unauthorized("Bearer token required"))
return
}
token, ok := parseBearerHeader(r)
if !ok {
w.Header().Set("WWW-Authenticate", wwwBearer)
apperr.Write(w, id, apperr.Unauthorized("Bearer token required"))
return
}
user, err := s.store.SessionUser(r.Context(), token)
if err != nil {
if store.IsUnavailable(err) {
apperr.Write(w, id, apperr.Unavailable("database unavailable"))
return
}
w.Header().Set("WWW-Authenticate", wwwBearer)
apperr.Write(w, id, apperr.Unauthorized("valid Bearer token required"))
return
}
ctx := context.WithValue(r.Context(), ctxUser, user)
ctx = context.WithValue(ctx, ctxToken, token)
next.ServeHTTP(w, r.WithContext(ctx))
}
}
// ─────────── Входная дверь: только Basic ───────────
func (s *Server) basicOnly(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
id := requestID(r)
creds, ok := parseBasicHeader(r)
if !ok {
w.Header().Set("WWW-Authenticate", wwwBasic)
apperr.Write(w, id, apperr.Unauthorized("Basic credentials required"))
return
}
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxCreds, creds)))
}
}
func currentUser(r *http.Request) *model.User { return r.Context().Value(ctxUser).(*model.User) }
func currentToken(r *http.Request) string { return r.Context().Value(ctxToken).(string) }
func currentCreds(r *http.Request) loginCreds { return r.Context().Value(ctxCreds).(loginCreds) }
+55
View File
@@ -0,0 +1,55 @@
package api
import (
"log/slog"
"net/http"
"sync/atomic"
"mtusi-messenger/internal/store"
)
type Server struct {
store *store.Store
log *slog.Logger
ready *atomic.Bool
instanceID string // LAB 3: ID реплики
}
func NewServer(st *store.Store, log *slog.Logger, ready *atomic.Bool, instanceID string) *Server {
return &Server{store: st, log: log, ready: ready, instanceID: instanceID}
}
func (s *Server) Handler() http.Handler {
mux := http.NewServeMux()
// Публичные (security: [] в OpenAPI):
mux.HandleFunc("/health/live", s.healthLive)
mux.HandleFunc("/health/ready", s.healthReady)
mux.HandleFunc("/api/v1/users", s.usersRoute)
// Вход — ТОЛЬКО Basic:
mux.HandleFunc("/api/v1/auth/sessions", s.basicOnly(s.createSession))
// Всё остальное — только Bearer:
mux.HandleFunc("/api/v1/auth/sessions/current", s.auth(s.revokeSession))
mux.HandleFunc("/api/v1/users/me", s.auth(s.me))
mux.HandleFunc("/api/v1/chats", s.auth(s.chatsRoute))
mux.HandleFunc("/api/v1/chats/{chat_id}", s.auth(s.chatRoute))
mux.HandleFunc("/api/v1/chats/{chat_id}/messages", s.auth(s.messagesRoute))
// ─────────── LAB 4: вложения ───────────
// Загрузка одного PNG/JPEG (сырые байты, НЕ multipart).
mux.HandleFunc("/api/v1/chats/{chat_id}/attachments", s.auth(s.attachmentsRoute))
// Метаданные вложения (доступ только участникам чата).
mux.HandleFunc("/api/v1/attachments/{attachment_id}", s.auth(s.attachmentRoute))
// Скачивание байтов через авторизованный API.
mux.HandleFunc("/api/v1/attachments/{attachment_id}/content", s.auth(s.attachmentContentRoute))
mux.HandleFunc("/", s.notFound)
var h http.Handler = mux
h = recoverMiddleware(s.log, h)
h = loggingMiddleware(s.log, h)
h = requestIDMiddleware(h)
h = instanceIDMiddleware(s.instanceID, h)
return h
}
+65
View File
@@ -0,0 +1,65 @@
package apperr
import (
"encoding/json"
"net/http"
)
type Code string
const (
CodeInvalidRequest Code = "invalid_request"
CodeUnauthorized Code = "unauthorized"
CodeNotFound Code = "not_found"
CodeConflict Code = "conflict"
CodePayloadTooLarge Code = "payload_too_large"
CodeUnsupportedMedia Code = "unsupported_media_type"
CodeRateLimited Code = "rate_limited"
CodeUnavailable Code = "unavailable"
CodeInternal Code = "internal_error"
)
type Body struct {
Code Code `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
type Envelope struct {
Error Body `json:"error"`
}
type AppError struct {
Status int
Code Code
Msg string
}
func (e *AppError) Error() string { return e.Msg }
func New(status int, code Code, msg string) *AppError {
return &AppError{Status: status, Code: code, Msg: msg}
}
func InvalidRequest(msg string) *AppError { return New(http.StatusBadRequest, CodeInvalidRequest, msg) }
func Unauthorized(msg string) *AppError { return New(http.StatusUnauthorized, CodeUnauthorized, msg) }
func NotFound(msg string) *AppError { return New(http.StatusNotFound, CodeNotFound, msg) }
func Conflict(msg string) *AppError { return New(http.StatusConflict, CodeConflict, msg) }
func PayloadTooLarge(msg string) *AppError {
return New(http.StatusRequestEntityTooLarge, CodePayloadTooLarge, msg)
}
func UnsupportedMedia(msg string) *AppError {
return New(http.StatusUnsupportedMediaType, CodeUnsupportedMedia, msg)
}
func Unavailable(msg string) *AppError {
return New(http.StatusServiceUnavailable, CodeUnavailable, msg)
}
func Internal(msg string) *AppError { return New(http.StatusInternalServerError, CodeInternal, msg) }
// Write отдаёт ошибку в формате контракта: {"error":{"code","message","request_id"}}.
func Write(w http.ResponseWriter, requestID string, err *AppError) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Request-Id", requestID)
w.WriteHeader(err.Status)
_ = json.NewEncoder(w).Encode(Envelope{Error: Body{Code: err.Code, Message: err.Msg, RequestID: requestID}})
}
+167
View File
@@ -0,0 +1,167 @@
package model
import (
"strconv"
"time"
)
// Timestamp — детерминированная сериализация времени (ровно 3 знака миллисекунд).
type Timestamp struct{ time.Time }
func (t Timestamp) MarshalJSON() ([]byte, error) {
s := t.UTC().Format("2006-01-02T15:04:05.000Z")
return strconv.AppendQuote(nil, s), nil
}
func NowTS() Timestamp { return Timestamp{Time: time.Now().UTC().Truncate(time.Millisecond)} }
// Состояния вложения/задания (лаба 5).
const (
StatusQueued = "queued"
StatusProcessing = "processing"
StatusReady = "ready"
StatusFailed = "failed"
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt Timestamp `json:"created_at"`
}
type CreateUserReq struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type LoginRequest struct {
Username string
Password string
}
type Session struct {
TokenHash []byte
UserID string
ExpiresAt time.Time
CreatedAt time.Time
}
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt Timestamp `json:"expires_at"`
User User `json:"user"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt Timestamp `json:"created_at"`
}
type CreateChatReq struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt Timestamp `json:"created_at"`
AttachmentIDs []string `json:"attachment_ids"`
}
type CreateMessageReq struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}
type Page[T any] struct {
Items []T `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type Health struct {
Status string `json:"status"`
}
// ─────────────────────── Вложения (lab4 → lab5) ───────────────────────
// Attachment — метаданные вложения. В лабе 5 status проходит путь
// queued → processing → ready|failed; variants заполняются только в ready.
type Attachment struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
OwnerID string `json:"owner_id"`
Filename string `json:"filename"`
ContentType string `json:"content_type"` // "image/png" | "image/jpeg"
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
Status string `json:"status"` // queued | processing | ready | failed
Variants []Variant `json:"variants"` // [] до ready
ErrorCode *string `json:"error_code"` // null до failed
CreatedAt Timestamp `json:"created_at"`
UpdatedAt Timestamp `json:"updated_at"`
// Внутренние поля, не отдаются клиенту.
PipelineVersion int `json:"-"`
ProcessingStartedAt *time.Time `json:"-"`
S3Key string `json:"-"` // ключ финального оригинала
}
// Variant — производная версия: thumbnail | crop | optimized.
type Variant struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
SHA256 string `json:"sha256"`
}
// ─────────────────────── Очередь (lab5) ───────────────────────
// Job — оркестрационная запись обработки (не отдаётся клиенту).
type Job struct {
ID string `json:"id"`
AttachmentID string `json:"attachment_id"`
Status string `json:"status"`
Attempt int `json:"attempt"`
MaxAttempts int `json:"max_attempts"`
NextAttemptAt *time.Time `json:"next_attempt_at,omitempty"`
LeaseID *string `json:"lease_id,omitempty"`
LeaseExpiresAt *time.Time `json:"lease_expires_at,omitempty"`
ErrorCode *string `json:"error_code,omitempty"`
ErrorMessage *string `json:"error_message,omitempty"`
PipelineVersion int `json:"pipeline_version"`
CreatedAt Timestamp `json:"created_at"`
UpdatedAt Timestamp `json:"updated_at"`
}
// JobMessage — сообщение брокера по contracts/jobs.schema.json.
// В очередь идут только ID и служебные поля, НЕ байты и НЕ credentials.
type JobMessage struct {
SchemaVersion int `json:"schema_version"`
JobID string `json:"job_id"`
Type string `json:"type"`
AttachmentID string `json:"attachment_id"`
PipelineVersion int `json:"pipeline_version"`
Attempt int `json:"attempt"`
CreatedAt string `json:"created_at"`
}
// OutboxMessage — строка transactional outbox.
type OutboxMessage struct {
ID string `json:"id"`
AggregateType string `json:"aggregate_type"`
AggregateID string `json:"aggregate_id"`
EventType string `json:"event_type"`
Payload []byte `json:"payload"`
CreatedAt Timestamp `json:"created_at"`
PublishedAt *time.Time `json:"published_at,omitempty"`
}
+64
View File
@@ -0,0 +1,64 @@
// Package store, attach.go — внутренний доступ к вложению (без проверки членства)
// и соглашение об object key лабы 5.
package store
import (
"context"
"encoding/json"
"errors"
"time"
"github.com/jackc/pgx/v5"
"mtusi-messenger/internal/model"
)
// StagingKey — ключ принятого оригинала до обработки.
func StagingKey(chatID, attachmentID string) string {
return "staging/" + chatID + "/" + attachmentID
}
// VariantKey — ключ финального объекта: оригинала или варианта.
// variant == "original" даёт ключ финального оригинала (совпадает с s3_key).
func VariantKey(chatID, attachmentID, variant string) string {
return chatID + "/" + attachmentID + "/" + variant
}
const attachCols = ` id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
s3_key, status, error_code, variants, pipeline_version, processing_started_at,
created_at, updated_at`
// GetAttachmentInternal — полное вложение для worker/reconcile (без ACL).
// ACL применяется только в публичных хендлерах.
func (s *Store) GetAttachmentInternal(ctx context.Context, id string) (*model.Attachment, error) {
return scanAttachment(s.pool.QueryRow(ctx, `SELECT`+attachCols+` FROM attachments WHERE id = $1`, id))
}
func scanAttachment(row pgx.Row) (*model.Attachment, error) {
var a model.Attachment
var createdAt, updatedAt time.Time
var variantsRaw []byte
var errCode *string
var startedAt *time.Time
err := row.Scan(
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType,
&a.SizeBytes, &a.SHA256, &a.S3Key, &a.Status, &errCode,
&variantsRaw, &a.PipelineVersion, &startedAt, &createdAt, &updatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
a.ErrorCode = errCode
a.ProcessingStartedAt = startedAt
a.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
a.UpdatedAt = model.Timestamp{Time: updatedAt.UTC()}
a.Variants = []model.Variant{}
if len(variantsRaw) > 0 {
if err := json.Unmarshal(variantsRaw, &a.Variants); err != nil {
return nil, err
}
}
return &a, nil
}
+223
View File
@@ -0,0 +1,223 @@
package store
import (
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strings"
"sync"
"time"
"github.com/redis/go-redis/v9"
"mtusi-messenger/internal/model"
)
// redisTimeout — максимальное время на одну Redis-операцию.
// При недоступном Redis клиент быстро возвращает ошибку, и мы деградируем
// в SQL, а не блокируем запрос (требование уровня 4 про потерю сервиса).
const redisTimeout = 300 * time.Millisecond
// ─────────────── Кэш сессий (уровень 4) ───────────────
func sessKey(hash [sha256.Size]byte) string { return "sess:" + hex.EncodeToString(hash[:]) }
// cacheSessionPut: TTL кэша = остаток срока сессии (политика expiry согласована
// с источником истины); при ошибке Redis — только warn, запрос живёт через SQL.
func (s *Store) cacheSessionPut(ctx context.Context, hash [sha256.Size]byte, userID string, expiresAt time.Time) {
if s.rdb == nil {
return
}
ttl := time.Until(expiresAt)
if ttl <= 0 {
return
}
val := userID + "|" + expiresAt.Format(time.RFC3339Nano)
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
if err := s.rdb.Set(rctx, sessKey(hash), val, ttl).Err(); err != nil {
s.log.Warn("redis set failed, degrading to postgres", "error", err.Error())
}
}
// cacheSessionGet: miss (redis.Nil) — норма; ошибка/таймаут Redis — деградация;
// истёкшее значение в кэше не доверяем (двойная страховка помимо TTL).
func (s *Store) cacheSessionGet(ctx context.Context, hash [sha256.Size]byte) (string, bool) {
if s.rdb == nil {
return "", false
}
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
val, err := s.rdb.Get(rctx, sessKey(hash)).Result()
if errors.Is(err, redis.Nil) {
return "", false
}
if err != nil {
s.log.Warn("redis get failed, degrading to postgres", "error", err.Error())
return "", false
}
parts := strings.SplitN(val, "|", 2)
if len(parts) != 2 {
return "", false
}
exp, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil || time.Now().UTC().After(exp) {
return "", false
}
return parts[0], true
}
func (s *Store) cacheSessionDel(ctx context.Context, hash [sha256.Size]byte) error {
if s.rdb == nil {
return nil
}
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
return s.rdb.Del(rctx, sessKey(hash)).Err()
}
// ─────────────── Версия чата (инвалидация кэша истории, трек 5) ───────────────
func chatVerKey(chatID string) string { return "chatver:" + chatID }
func (s *Store) bumpChatVersion(ctx context.Context, chatID string) {
if s.rdb == nil {
return
}
var err error
for attempt := 1; attempt <= 3; attempt++ {
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
err = s.rdb.Incr(rctx, chatVerKey(chatID)).Err()
cancel()
if err == nil {
return
}
s.log.Warn("redis incr failed, retrying", "attempt", attempt, "error", err.Error())
time.Sleep(50 * time.Millisecond)
}
s.log.Warn("redis incr failed after retries; history cache bounded stale until TTL", "error", err.Error())
}
// ChatVersion: 0 при отсутствии Redis/ключа — кэш истории тогда не используется,
// корректность не страдает.
func (s *Store) ChatVersion(ctx context.Context, chatID string) int64 {
if s.rdb == nil {
return 0
}
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
v, err := s.rdb.Get(rctx, chatVerKey(chatID)).Int64()
if err != nil {
return 0
}
return v
}
// ─────────────── Кэш истории (трек 5) ───────────────
// HistoryCacheKey — ключ страницы истории: версия чата + параметры запроса.
// Версия в ключе — это и есть защита от stale read.
func HistoryCacheKey(chatID string, version int64, cursorJSON string, limit int) string {
return fmt.Sprintf("hist:v%d:%s:%s:%d", version, chatID, cursorJSON, limit)
}
// CacheHistoryPut — положить страницу в кэш. TTL 60 c: кэш для горячего чтения,
// не долгосрочное хранилище; источник истины остаётся Postgres.
func (s *Store) CacheHistoryPut(ctx context.Context, key string, messages []*model.Message, hasMore bool) {
if s.rdb == nil {
return
}
data := map[string]any{
"items": messages,
"has_more": hasMore,
"cached_at": time.Now().UTC().Format(time.RFC3339Nano),
}
b, err := json.Marshal(data)
if err != nil {
return
}
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
if err := s.rdb.Set(rctx, key, b, 60*time.Second).Err(); err != nil {
s.log.Warn("redis history set failed", "error", err.Error())
}
}
// CacheHistoryGet — достать страницу из кэша: (items, hasMore, ok).
// ok=false означает miss или ошибку Redis — тогда идём в SQL.
func (s *Store) CacheHistoryGet(ctx context.Context, key string) ([]*model.Message, bool, bool) {
if s.rdb == nil {
return nil, false, false
}
rctx, cancel := context.WithTimeout(ctx, redisTimeout)
defer cancel()
val, err := s.rdb.Get(rctx, key).Result()
if err != nil {
return nil, false, false
}
var data struct {
Items []*model.Message `json:"items"`
HasMore bool `json:"has_more"`
}
if err := json.Unmarshal([]byte(val), &data); err != nil {
return nil, false, false
}
return data.Items, data.HasMore, true
}
// ─────────────── Single-flight (защита от cache stampede) ───────────────
// При конкурирующих холодных чтениях одного ключа только один поток выполняет
// fn; остальные ждут его результат. Без этого N конкурентных miss дали бы N
// SQL-запросов («лавиной») — это и есть cache stampede.
type SingleFlight struct {
mu sync.Mutex
m map[string]*call
}
type call struct {
wg sync.WaitGroup
val any
err error
}
func NewSingleFlight() *SingleFlight {
return &SingleFlight{m: make(map[string]*call)}
}
// Do выполняет fn только если нет активного вызова с тем же key; иначе ждёт
// готовый результат того вызова.
func (sf *SingleFlight) Do(key string, fn func() (any, error)) (any, error) {
sf.mu.Lock()
if c, ok := sf.m[key]; ok {
sf.mu.Unlock()
c.wg.Wait()
return c.val, c.err
}
c := new(call)
c.wg.Add(1)
sf.m[key] = c
sf.mu.Unlock()
c.val, c.err = fn()
c.wg.Done()
sf.mu.Lock()
delete(sf.m, key)
sf.mu.Unlock()
return c.val, c.err
}
// EncodeCursorJSON — компактное представление курсора для ключа кэша.
func EncodeCursorJSON(c *Cursor) string {
if c == nil {
return "null"
}
b, _ := json.Marshal(c)
return base64.RawURLEncoding.EncodeToString(b)
}
+515
View File
@@ -0,0 +1,515 @@
// Package store, jobs.go — жизненный цикл заданий обработки и transactional
// outbox (лаба 5).
//
// Инварианты:
// - намерение обработать (attachment + job + outbox) фиксируется ОДНОЙ
// транзакцией до ответа 202;
// - публикация в брокер — отдельный relay, читающий outbox; разрыв
// COMMIT -> publish восстанавливается автоматически;
// - claim атомарен: одну job не берут два worker'а (lease + статус-гард);
// - результат (ready/failed/retry) пишется транзакцией вместе с attachment;
// - ack только после COMMIT результата.
package store
import (
"context"
"encoding/json"
"errors"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"mtusi-messenger/internal/model"
)
const (
// DefaultMaxAttempts — ограниченный retry (требование уровня 3).
DefaultMaxAttempts = 5
// LeaseTTL — аренда обработки; после истечения job считается зависшей.
LeaseTTL = 60 * time.Second
)
// ClaimedJob — успешно захваченная работа.
type ClaimedJob struct {
JobID string
AttachmentID string
Attempt int
PipelineVersion int
}
// CreateQueuedAttachment — атомарная фиксация принятого оригинала:
// attachment(status=queued) + job + outbox-сообщение в ОДНОЙ транзакции.
// Вызывается до ответа 202: после commit работа не теряется даже при падении API.
func (s *Store) CreateQueuedAttachment(ctx context.Context, att *model.Attachment) (*model.Attachment, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback(ctx)
now := model.NowTS()
att.Status = model.StatusQueued
att.Variants = []model.Variant{}
att.ErrorCode = nil
att.PipelineVersion = 1
_, err = tx.Exec(ctx, `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
s3_key, status, error_code, pipeline_version, created_at, updated_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)`,
att.ID, att.ChatID, att.OwnerID, att.Filename, att.ContentType,
att.SizeBytes, att.SHA256, att.S3Key, att.Status, att.ErrorCode,
att.PipelineVersion, now.Time, now.Time)
if err != nil {
return nil, err
}
jobID := uuid.NewString()
_, err = tx.Exec(ctx, `
INSERT INTO jobs
(id, attachment_id, status, attempt, max_attempts, pipeline_version, created_at, updated_at)
VALUES ($1,$2,$3,0,$4,$5,$6,$7)`,
jobID, att.ID, model.StatusQueued, DefaultMaxAttempts,
att.PipelineVersion, now.Time, now.Time)
if err != nil {
return nil, err
}
msg := model.JobMessage{
SchemaVersion: 1,
JobID: jobID,
Type: "attachment.process.v1",
AttachmentID: att.ID,
PipelineVersion: att.PipelineVersion,
Attempt: 1,
CreatedAt: now.Time.UTC().Format("2006-01-02T15:04:05.000Z"),
}
payload, err := json.Marshal(msg)
if err != nil {
return nil, err
}
_, err = tx.Exec(ctx, `
INSERT INTO outbox (id, aggregate_type, aggregate_id, event_type, payload, created_at)
VALUES ($1,$2,$3,$4,$5,$6)`,
uuid.NewString(), "attachment", att.ID, msg.Type, payload, now.Time)
if err != nil {
return nil, err
}
if err := tx.Commit(ctx); err != nil {
return nil, err
}
att.CreatedAt = now
att.UpdatedAt = now
return att, nil
}
// ─────────────── Outbox relay ───────────────
// FetchUnpublishedOutbox — порция неопубликованных намерений (старые сначала).
func (s *Store) FetchUnpublishedOutbox(ctx context.Context, limit int) ([]model.OutboxMessage, error) {
rows, err := s.pool.Query(ctx, `
SELECT id, aggregate_type, aggregate_id, event_type, payload, created_at
FROM outbox
WHERE published_at IS NULL
ORDER BY created_at
LIMIT $1`, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var out []model.OutboxMessage
for rows.Next() {
var m model.OutboxMessage
var createdAt time.Time
if err := rows.Scan(&m.ID, &m.AggregateType, &m.AggregateID, &m.EventType, &m.Payload, &createdAt); err != nil {
return nil, err
}
m.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
out = append(out, m)
}
return out, rows.Err()
}
// MarkOutboxPublished — отметить опубликованным ПОСЛЕ успеха XADD.
func (s *Store) MarkOutboxPublished(ctx context.Context, id string) error {
_, err := s.pool.Exec(ctx, `UPDATE outbox SET published_at = now() WHERE id = $1`, id)
return err
}
// ─────────────── Worker: claim / complete / fail / retry ───────────────
// ClaimJob — атомарный захват работы с lease. Возвращает nil, если job уже
// в терминальном состоянии, в backoff-окне, под живой арендой, либо попытки
// исчерпаны (такую работу закрывает только ReapExpiredLeases).
//
// ВАЖНО (ревью): attempt монотонен — GREATEST(jobs.attempt, $2). Старое
// сообщение-дубль с меньшим номером попытки НЕ может откатить счётчик назад
// и обойти ограниченный retry. Захват истёкшей аренды разрешён только пока
// attempt < max_attempts, иначе исчерпанную работу воскресил бы любой дубль.
func (s *Store) ClaimJob(ctx context.Context, jobID string, attempt int, leaseID string, expiresAt time.Time) (*ClaimedJob, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback(ctx)
var c ClaimedJob
err = tx.QueryRow(ctx, `
UPDATE jobs
SET status = 'processing',
attempt = GREATEST(jobs.attempt, $2),
lease_id = $3,
lease_expires_at = $4,
updated_at = now()
WHERE id = $1
AND (
(status = 'queued' AND (next_attempt_at IS NULL OR next_attempt_at <= now()))
OR (status = 'processing' AND lease_expires_at < now() AND attempt < max_attempts)
)
RETURNING id, attachment_id, attempt, pipeline_version`,
jobID, attempt, leaseID, expiresAt.UTC()).
Scan(&c.JobID, &c.AttachmentID, &c.Attempt, &c.PipelineVersion)
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil // не захватываемо: терминал / backoff / живая аренда / попытки исчерпаны
}
if err != nil {
return nil, err
}
_, err = tx.Exec(ctx, `
UPDATE attachments
SET status = 'processing', processing_started_at = now(), updated_at = now()
WHERE id = $1 AND status IN ('queued','processing')`, c.AttachmentID)
if err != nil {
return nil, err
}
if err := tx.Commit(ctx); err != nil {
return nil, err
}
return &c, nil
}
// CompleteJob — атомарная фиксация результата: ready + варианты (ключ эффекта
// (attachment_id, pipeline_version, variant) не дублируется при повторе).
func (s *Store) CompleteJob(ctx context.Context, attachmentID string, variants []model.Variant) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return err
}
defer tx.Rollback(ctx)
b, err := json.Marshal(variants)
if err != nil {
return err
}
_, err = tx.Exec(ctx, `
UPDATE attachments
SET status = 'ready', variants = $2, error_code = NULL, updated_at = now()
WHERE id = $1 AND status IN ('processing','queued')`, attachmentID, b)
if err != nil {
return err
}
_, err = tx.Exec(ctx, `
UPDATE jobs
SET status = 'ready', lease_id = NULL, lease_expires_at = NULL,
error_code = NULL, error_message = NULL, updated_at = now()
WHERE attachment_id = $1 AND status IN ('processing','queued')`, attachmentID)
if err != nil {
return err
}
return tx.Commit(ctx)
}
// FailJob — терминальный отказ с машинным error_code и записью в реестр failed.
func (s *Store) FailJob(ctx context.Context, attachmentID, code, message string) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return err
}
defer tx.Rollback(ctx)
var jobID string
var attempt int
err = tx.QueryRow(ctx, `
SELECT id, attempt FROM jobs WHERE attachment_id = $1`, attachmentID).Scan(&jobID, &attempt)
if err != nil {
return err
}
_, err = tx.Exec(ctx, `
UPDATE attachments
SET status = 'failed', error_code = $2, variants = '[]', updated_at = now()
WHERE id = $1`, attachmentID, code)
if err != nil {
return err
}
_, err = tx.Exec(ctx, `
UPDATE jobs
SET status = 'failed', lease_id = NULL, lease_expires_at = NULL,
error_code = $2, error_message = $3, updated_at = now()
WHERE id = $1`, jobID, code, message)
if err != nil {
return err
}
_, err = tx.Exec(ctx, `
INSERT INTO job_failures (id, job_id, attachment_id, error_code, error_message, attempt, failed_at)
VALUES ($1,$2,$3,$4,$5,$6,now())`,
uuid.NewString(), jobID, attachmentID, code, message, attempt)
if err != nil {
return err
}
return tx.Commit(ctx)
}
// ScheduleRetry — временная ошибка: job возвращается в queued с отложенной
// попыткой, намерение опубликовать сообщение пишется в outbox той же транзакцией.
func (s *Store) ScheduleRetry(ctx context.Context, attachmentID string, nextAt time.Time, tempCode string) (bool, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return false, err
}
defer tx.Rollback(ctx)
var jobID string
var attempt, pipelineVersion int
err = tx.QueryRow(ctx, `
UPDATE jobs
SET status = 'queued', lease_id = NULL, lease_expires_at = NULL,
next_attempt_at = $2, error_code = $3, updated_at = now()
WHERE attachment_id = $1 AND status = 'processing'
RETURNING id, attempt, pipeline_version`, attachmentID, nextAt.UTC(), tempCode).
Scan(&jobID, &attempt, &pipelineVersion)
if errors.Is(err, pgx.ErrNoRows) {
return false, nil
}
if err != nil {
return false, err
}
_, err = tx.Exec(ctx, `
UPDATE attachments SET status = 'queued', updated_at = now()
WHERE id = $1`, attachmentID)
if err != nil {
return false, err
}
msg := model.JobMessage{
SchemaVersion: 1,
JobID: jobID,
Type: "attachment.process.v1",
AttachmentID: attachmentID,
PipelineVersion: pipelineVersion,
Attempt: attempt + 1,
CreatedAt: time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
}
payload, err := json.Marshal(msg)
if err != nil {
return false, err
}
_, err = tx.Exec(ctx, `
INSERT INTO outbox (id, aggregate_type, aggregate_id, event_type, payload, created_at)
VALUES ($1,$2,$3,$4,$5,now())`,
uuid.NewString(), "attachment", attachmentID, msg.Type, payload)
if err != nil {
return false, err
}
return true, tx.Commit(ctx)
}
// ReapExpiredLeases — защита от зависшего processing (уровень 4).
// Истёкшая аренда возвращает job в queued (если остались попытки) или
// переводит в failed с записью в реестр отказов.
//
// ВАЖНО (ревью): результат каждого RETURNING-запроса сначала полностью
// вычитывается в срез и закрывается, и только потом выполняются tx.Exec.
// Транзакция pgx держит одно соединение, поэтому запрос при открытом
// результате даёт "conn busy" и теряет фиксацию failed.
func (s *Store) ReapExpiredLeases(ctx context.Context) (int, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return 0, err
}
defer tx.Rollback(ctx)
type reapedJob struct {
jobID string
attachmentID string
attempt int
pipeline int
}
// ── 1. Истёкшая аренда, попытки остались → обратно в queued ──
rows, err := tx.Query(ctx, `
UPDATE jobs
SET status = 'queued', lease_id = NULL, lease_expires_at = NULL,
next_attempt_at = now(), updated_at = now()
WHERE status = 'processing' AND lease_expires_at < now() AND attempt < max_attempts
RETURNING id, attachment_id, attempt, pipeline_version`)
if err != nil {
return 0, err
}
var requeued []reapedJob
for rows.Next() {
var r reapedJob
if err := rows.Scan(&r.jobID, &r.attachmentID, &r.attempt, &r.pipeline); err != nil {
rows.Close()
return 0, err
}
requeued = append(requeued, r)
}
rows.Close()
if err := rows.Err(); err != nil {
return 0, err
}
for _, r := range requeued {
if _, err := tx.Exec(ctx, `
UPDATE attachments SET status = 'queued', updated_at = now()
WHERE id = $1`, r.attachmentID); err != nil {
return 0, err
}
msg := model.JobMessage{
SchemaVersion: 1,
JobID: r.jobID,
Type: "attachment.process.v1",
AttachmentID: r.attachmentID,
PipelineVersion: r.pipeline,
Attempt: r.attempt + 1,
CreatedAt: time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
}
payload, err := json.Marshal(msg)
if err != nil {
return 0, err
}
if _, err := tx.Exec(ctx, `
INSERT INTO outbox (id, aggregate_type, aggregate_id, event_type, payload, created_at)
VALUES ($1,$2,$3,$4,$5,now())`,
uuid.NewString(), "attachment", r.attachmentID, msg.Type, payload); err != nil {
return 0, err
}
}
// ── 2. Истёкшая аренда, попытки исчерпаны → failed ──
// Сначала вычитываем и закрываем результат, затем фиксируем отказ.
exhaustedRows, err := tx.Query(ctx, `
UPDATE jobs
SET status = 'failed', lease_id = NULL, lease_expires_at = NULL,
error_code = 'retry_exhausted', error_message = 'lease expired with no attempts left',
updated_at = now()
WHERE status = 'processing' AND lease_expires_at < now() AND attempt >= max_attempts
RETURNING id, attachment_id, attempt`)
if err != nil {
return 0, err
}
var exhausted []reapedJob
for exhaustedRows.Next() {
var r reapedJob
if err := exhaustedRows.Scan(&r.jobID, &r.attachmentID, &r.attempt); err != nil {
exhaustedRows.Close()
return 0, err
}
exhausted = append(exhausted, r)
}
exhaustedRows.Close()
if err := exhaustedRows.Err(); err != nil {
return 0, err
}
for _, r := range exhausted {
if _, err := tx.Exec(ctx, `
UPDATE attachments
SET status = 'failed', error_code = 'retry_exhausted', variants = '[]', updated_at = now()
WHERE id = $1`, r.attachmentID); err != nil {
return 0, err
}
if _, err := tx.Exec(ctx, `
INSERT INTO job_failures (id, job_id, attachment_id, error_code, error_message, attempt, failed_at)
VALUES ($1,$2,$3,'retry_exhausted','lease expired with no attempts left',$4,now())`,
uuid.NewString(), r.jobID, r.attachmentID, r.attempt); err != nil {
return 0, err
}
}
if err := tx.Commit(ctx); err != nil {
return 0, err
}
return len(requeued), nil
}
// EnqueueDueRetries — планировщик отложенных повторов (лаба 5, уровень 4).
//
// Зачем нужен: Redis Streams не умеет отложенную доставку. Backoff хранится
// в jobs.next_attempt_at, а момент публикации контролирует этот планировщик:
// он выбирает задания, у которых срок настал, сбрасывает срок и пишет
// намерение опубликовать в outbox (той же транзакцией).
//
// ВАЖНО (замечание ревью): результат RETURNING-запроса сначала полностью
// вычитывается в срез и закрывается, и только потом выполняются tx.Exec.
// Транзакция pgx держит одно соединение, поэтому запрос при открытом
// результате даёт "conn busy".
func (s *Store) EnqueueDueRetries(ctx context.Context) (int, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return 0, err
}
defer tx.Rollback(ctx)
rows, err := tx.Query(ctx, `
UPDATE jobs
SET next_attempt_at = NULL, updated_at = now()
WHERE status = 'queued' AND next_attempt_at IS NOT NULL AND next_attempt_at <= now()
RETURNING id, attachment_id, attempt, pipeline_version`)
if err != nil {
return 0, err
}
type dueJob struct {
jobID string
attachmentID string
attempt int
pipeline int
}
var due []dueJob
for rows.Next() {
var d dueJob
if err := rows.Scan(&d.jobID, &d.attachmentID, &d.attempt, &d.pipeline); err != nil {
rows.Close()
return 0, err
}
due = append(due, d)
}
rows.Close()
if err := rows.Err(); err != nil {
return 0, err
}
for _, d := range due {
msg := model.JobMessage{
SchemaVersion: 1,
JobID: d.jobID,
Type: "attachment.process.v1",
AttachmentID: d.attachmentID,
PipelineVersion: d.pipeline,
Attempt: d.attempt + 1,
CreatedAt: time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
}
payload, err := json.Marshal(msg)
if err != nil {
return 0, err
}
if _, err := tx.Exec(ctx, `
INSERT INTO outbox (id, aggregate_type, aggregate_id, event_type, payload, created_at)
VALUES ($1,$2,$3,$4,$5,now())`,
uuid.NewString(), "attachment", d.attachmentID, msg.Type, payload); err != nil {
return 0, err
}
}
if err := tx.Commit(ctx); err != nil {
return 0, err
}
return len(due), nil
}
+47
View File
@@ -0,0 +1,47 @@
package store
import (
"context"
"embed"
"fmt"
"io/fs"
"log/slog"
"path/filepath"
"sort"
"strings"
"github.com/jackc/pgx/v5/pgxpool"
)
//go:embed migrations/*.sql
var migrationsFS embed.FS
// RunMigrations запускает все миграции из папки migrations/ по алфавиту.
// Идемпотентно: IF NOT EXISTS в SQL защищает от дублей.
func RunMigrations(ctx context.Context, pool *pgxpool.Pool, log *slog.Logger) error {
entries, err := fs.ReadDir(migrationsFS, "migrations")
if err != nil {
return fmt.Errorf("read migrations dir: %w", err)
}
// Сортируем по имени файла (0001_init.sql, 0002_..., ...)
var files []string
for _, e := range entries {
if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") {
files = append(files, e.Name())
}
}
sort.Strings(files)
for _, name := range files {
sql, err := fs.ReadFile(migrationsFS, filepath.Join("migrations", name))
if err != nil {
return fmt.Errorf("read migration %s: %w", name, err)
}
log.Info("running migration", "file", name)
if _, err := pool.Exec(ctx, string(sql)); err != nil {
return fmt.Errorf("exec migration %s: %w", name, err)
}
}
return nil
}
@@ -0,0 +1,48 @@
-- Все операции идемпотентны (IF NOT EXISTS)
-- Пользователи
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_re CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE UNIQUE INDEX IF NOT EXISTS users_username_key ON users (username);
-- Чаты
CREATE TABLE IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT now()
);
-- Участники чатов
CREATE TABLE IF NOT EXISTS 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 IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id);
-- Сообщения
CREATE TABLE IF NOT EXISTS messages (
id uuid NOT NULL,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (chat_id, id)
);
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
-- Сессии (источник истины)
CREATE TABLE IF NOT EXISTS sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at);
@@ -0,0 +1,14 @@
-- Lab 3: идемпотентность отправки сообщений.
-- Все операции идемпотентны (IF NOT EXISTS).
-- Область ключа: (chat_id, sender_id, idempotency_key).
-- Это пользователь + путь + ключ для фиксированного метода POST.
ALTER TABLE messages
ADD COLUMN IF NOT EXISTS idempotency_key text;
-- У старых сообщений ключа нет (NULL).
-- В Postgres NULL'ы в уникальном индексе считаются различающимися,
-- поэтому старый контент не нарушит уникальность.
CREATE UNIQUE INDEX IF NOT EXISTS messages_idempotency_uq
ON messages (chat_id, sender_id, idempotency_key);
@@ -0,0 +1,27 @@
CREATE TABLE IF NOT EXISTS attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
owner_id uuid NOT NULL REFERENCES users(id),
filename text NOT NULL,
content_type text NOT NULL, -- 'image/png' | 'image/jpeg' (MIME по содержимому)
size_bytes bigint NOT NULL CHECK (size_bytes >= 1 AND size_bytes <= 10485760),
sha256 text NOT NULL, -- lowercase hex, 64 символа
s3_key text NOT NULL UNIQUE, -- внутренний ключ бакета; НЕ отдаётся клиенту
status text NOT NULL DEFAULT 'ready', -- в лабе 4 всегда 'ready'
error_code text, -- в лабе 4 всегда NULL
created_at timestamptz NOT NULL,
updated_at timestamptz NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments(chat_id);
-- ============================================================
-- LAB 4: сообщения ссылаются на вложения этого чата.
-- ============================================================
-- Массив хранит 0..10 уникальных UUID. Ограничения по количеству и
-- уникальности, а также принадлежность вложений ИМЕННО этому чату
-- проверяются в приложении при создании сообщения (см. handlers.go).
--
-- Старые текстовые сообщения получают пустой массив '{}' — это сохраняет
-- обратную совместимость и обязательное поле контракта "attachment_ids".
ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids uuid[] NOT NULL DEFAULT '{}';
@@ -0,0 +1,18 @@
-- LAB 4: разрешаем пустой текст, если сообщение содержит хотя бы одно вложение.
--
-- Контракт lab4:
-- либо text непустой (1..4000),
-- либо attachment_ids содержит хотя бы один элемент.
--
-- Старое ограничение lab3 требовало char_length(text) >= 1 всегда,
-- поэтому оно ломает сообщения вида {"text":"","attachment_ids":[...]}.
ALTER TABLE messages
DROP CONSTRAINT IF EXISTS messages_text_check;
ALTER TABLE messages
ADD CONSTRAINT messages_text_check CHECK (
(char_length(text) >= 1 AND char_length(text) <= 4000)
OR
(char_length(text) = 0 AND cardinality(attachment_ids) > 0)
);
@@ -0,0 +1,62 @@
-- LAB 5: очередь заданий, transactional outbox, реестр failed.
--
-- jobs — оркестрация обработки: попытки, lease, backoff, финальная ошибка.
-- outbox — намерение опубликовать сообщение в брокер, записанное в той же
-- транзакции, что и данные; relay читает и публикует (закрытие
-- разрыва COMMIT -> publish).
-- job_failures — реестр failed (DLQ) для оператора.
--
-- Состояние для клиента живёт в attachments.status (queued/processing/ready/failed).
CREATE TABLE IF NOT EXISTS jobs (
id UUID PRIMARY KEY,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
status TEXT NOT NULL DEFAULT 'queued',
attempt INTEGER NOT NULL DEFAULT 0,
max_attempts INTEGER NOT NULL DEFAULT 5,
next_attempt_at TIMESTAMPTZ,
lease_id TEXT,
lease_expires_at TIMESTAMPTZ,
error_code TEXT,
error_message TEXT,
pipeline_version INTEGER NOT NULL DEFAULT 1,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE UNIQUE INDEX IF NOT EXISTS uq_jobs_attachment ON jobs (attachment_id);
CREATE INDEX IF NOT EXISTS idx_jobs_claimable ON jobs (status, next_attempt_at);
CREATE INDEX IF NOT EXISTS idx_jobs_stuck ON jobs (status, lease_expires_at);
CREATE TABLE IF NOT EXISTS outbox (
id UUID PRIMARY KEY,
aggregate_type TEXT NOT NULL,
aggregate_id UUID NOT NULL,
event_type TEXT NOT NULL,
payload JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
published_at TIMESTAMPTZ
);
CREATE INDEX IF NOT EXISTS idx_outbox_unpublished
ON outbox (created_at)
WHERE published_at IS NULL;
CREATE TABLE IF NOT EXISTS job_failures (
id UUID PRIMARY KEY,
job_id UUID NOT NULL,
attachment_id UUID NOT NULL,
error_code TEXT NOT NULL,
error_message TEXT,
attempt INTEGER NOT NULL,
failed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_job_failures_attachment ON job_failures (attachment_id);
-- LAB 5: версия pipeline и время старта обработки для наблюдаемости.
-- LAB 5: варианты, версия pipeline и время старта обработки.
ALTER TABLE attachments
ADD COLUMN IF NOT EXISTS variants JSONB NOT NULL DEFAULT '[]',
ADD COLUMN IF NOT EXISTS pipeline_version INTEGER NOT NULL DEFAULT 1,
ADD COLUMN IF NOT EXISTS processing_started_at TIMESTAMPTZ;
+717
View File
@@ -0,0 +1,717 @@
// Package store — слой доступа к данным lab2+lab4.
// PostgreSQL = источник истины (пользователи, чаты, участники, сообщения, сессии,
// метаданные вложений).
// Redis = опциональный кэш (сессии + история в треке 5): при его потере
// деградируем в SQL, а не отказываем.
// S3-совместимое хранилище = источник истины для БАЙТОВ вложений (лаба 4).
//
// ВСЕ запросы параметризованы ($1, $2, ...): значения никогда не конкатенируются
// в текст SQL — это защита от SQL-инъекций.
package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"log/slog"
"net"
"sort"
"strconv"
"strings"
"time"
"mtusi-messenger/internal/model"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
"golang.org/x/crypto/scrypt"
)
// Sentinel-ошибки: store НЕ ЗНАЕТ про HTTP; хендлеры маппят флажки в статусы.
var (
ErrNotFound = errors.New("not found") // объекта нет ИЛИ он чужой
ErrUsernameTaken = errors.New("username taken") // unique-ограничение
ErrInvalidCursor = errors.New("invalid cursor") // битая/чужая закладка
ErrInvalidLogin = errors.New("invalid credentials") // неверный пароль ИЛИ неизвестный user (намеренно одно!)
ErrBadMembers = errors.New("invalid member_ids") // неизвестный участник / вызывающий не в списке
ErrIdempotencyConflict = errors.New("idempotency conflict") // тот же ключ, но другое тело
)
// Store — доступ к PostgreSQL (+ опциональный Redis) + S3-хранилище (лаба 4).
type Store struct {
pool *pgxpool.Pool // ограниченный пул соединений (уровень 4)
rdb *redis.Client // nil = режим деградации без кэша
s3 *S3Client // приватное S3-совместимое хранилище (лаба 4)
sessionTTL time.Duration // из SESSION_TTL_SECONDS
cacheMode string // "off" | "naive" | "versioned"; дефолт versioned (трек 5)
log *slog.Logger
sf *SingleFlight // stampede-защита кэша истории (трек 5)
}
// New собирает Store. s3 может быть nil в случае недоступности — тогда все
// операции с вложениями вернут ErrNotFound/503 (хендлеры маппят IsS3Unavailable).
func New(pool *pgxpool.Pool, rdb *redis.Client, s3 *S3Client, sessionTTLSeconds, cacheMode string, log *slog.Logger) *Store {
ttl := 3600
if v, err := strconv.Atoi(sessionTTLSeconds); err == nil && v > 0 {
ttl = v
}
if cacheMode == "" {
cacheMode = "versioned"
}
return &Store{
pool: pool,
rdb: rdb,
s3: s3,
sessionTTL: time.Duration(ttl) * time.Second,
cacheMode: cacheMode,
log: log,
sf: NewSingleFlight(),
}
}
// Ping — живость БД; используется в /health/ready: БД мертва => 503.
func (s *Store) Ping(ctx context.Context) error { return s.pool.Ping(ctx) }
// ─────────────── Курсор и пагинация (перенесено из lab1 без изменений) ───────────────
type Cursor struct {
Scope string `json:"s"` // чей ресурс: id чата или id пользователя
TS time.Time `json:"t"` // время записи-закладки
ID string `json:"i"` // id записи-закладки
}
func EncodeCursor(c Cursor) string {
b, _ := json.Marshal(c)
return base64.RawURLEncoding.EncodeToString(b)
}
func DecodeCursor(s string) (Cursor, error) {
var c Cursor
b, err := base64.RawURLEncoding.DecodeString(s)
if err != nil {
return c, ErrInvalidCursor
}
if err := json.Unmarshal(b, &c); err != nil {
return c, ErrInvalidCursor
}
if c.Scope == "" || c.ID == "" || c.TS.IsZero() {
return c, ErrInvalidCursor
}
return c, nil
}
func lessPair(ai time.Time, aid string, bi time.Time, bid string) bool {
if !ai.Equal(bi) {
return ai.Before(bi)
}
return aid < bid
}
// paginate — дженерик листания для списков, собранных в памяти (список чатов).
// История сообщений листается НА СТОРОНЕ SQL (см. ListMessages).
func paginate[T any](all []T, limit int, cur *Cursor, key func(T) (time.Time, string)) ([]T, bool) {
start := 0
if cur != nil {
start = sort.Search(len(all), func(i int) bool {
t, id := key(all[i])
return lessPair(cur.TS, cur.ID, t, id)
})
}
rest := all[start:]
if len(rest) > limit {
return rest[:limit], true
}
return rest, false
}
// ─────────────── Пароли: KDF scrypt ───────────────
const (
scryptN = 32768 // 2^15
scryptR = 8
scryptP = 1
scryptKeyLen = 32
saltLen = 16
)
func HashPassword(password string) (string, error) {
salt := make([]byte, saltLen)
if _, err := rand.Read(salt); err != nil {
return "", err
}
h, err := scrypt.Key([]byte(password), salt, scryptN, scryptR, scryptP, scryptKeyLen)
if err != nil {
return "", err
}
enc := base64.RawStdEncoding.EncodeToString
return fmt.Sprintf("scrypt$%d$%d$%d$%s$%s", scryptN, scryptR, scryptP, enc(salt), enc(h)), nil
}
func VerifyPassword(password, encoded string) bool {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[0] != "scrypt" {
return false
}
N, e1 := strconv.Atoi(parts[1])
r, e2 := strconv.Atoi(parts[2])
p, e3 := strconv.Atoi(parts[3])
if e1 != nil || e2 != nil || e3 != nil {
return false
}
salt, e4 := base64.RawStdEncoding.DecodeString(parts[4])
want, e5 := base64.RawStdEncoding.DecodeString(parts[5])
if e4 != nil || e5 != nil {
return false
}
got, err := scrypt.Key([]byte(password), salt, N, r, p, len(want))
if err != nil {
return false
}
return subtle.ConstantTimeCompare(want, got) == 1
}
// isUniqueViolation — SQLSTATE 23505: нарушение UNIQUE (гонка регистрации).
func isUniqueViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23505"
}
// ─────────────── Пользователи ───────────────
func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*model.User, error) {
hash, err := HashPassword(password)
if err != nil {
return nil, err
}
u := &model.User{ID: uuid.NewString(), Username: username, DisplayName: displayName, CreatedAt: model.NowTS()}
_, err = s.pool.Exec(ctx,
`INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES ($1, $2, $3, $4, $5)`,
u.ID, u.Username, u.DisplayName, hash, u.CreatedAt.Time)
if err != nil {
if isUniqueViolation(err) {
return nil, ErrUsernameTaken
}
return nil, err
}
return u, nil
}
const userCols = `id, username, display_name, created_at`
func (s *Store) User(ctx context.Context, id string) (*model.User, error) {
var u model.User
var createdAt time.Time
err := s.pool.QueryRow(ctx, `SELECT `+userCols+` FROM users WHERE id = $1`, id).
Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
u.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
return &u, nil
}
func (s *Store) UserByCredentials(ctx context.Context, username, password string) (*model.User, error) {
var u model.User
var createdAt time.Time
var hash string
err := s.pool.QueryRow(ctx,
`SELECT `+userCols+`, password_hash FROM users WHERE username = $1`, username).
Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &hash)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrInvalidLogin
}
if err != nil {
return nil, err
}
if !VerifyPassword(password, hash) {
return nil, ErrInvalidLogin
}
u.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
return &u, nil
}
// ─────────────── Сессии ───────────────
func (s *Store) CreateSession(ctx context.Context, userID string) (string, time.Time, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return "", time.Time{}, err
}
token := base64.RawURLEncoding.EncodeToString(raw)
hash := sha256.Sum256([]byte(token))
expiresAt := time.Now().UTC().Add(s.sessionTTL)
_, err := s.pool.Exec(ctx,
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`,
hash[:], userID, expiresAt)
if err != nil {
return "", time.Time{}, err
}
s.cacheSessionPut(ctx, hash, userID, expiresAt)
return token, expiresAt, nil
}
func (s *Store) SessionUser(ctx context.Context, token string) (*model.User, error) {
hash := sha256.Sum256([]byte(token))
if userID, ok := s.cacheSessionGet(ctx, hash); ok {
return s.User(ctx, userID)
}
var userID string
var expiresAt time.Time
err := s.pool.QueryRow(ctx,
`SELECT user_id, expires_at FROM sessions WHERE token_hash = $1`, hash[:]).
Scan(&userID, &expiresAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
if time.Now().UTC().After(expiresAt) {
_, _ = s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:])
s.cacheSessionDel(ctx, hash)
return nil, ErrNotFound
}
s.cacheSessionPut(ctx, hash, userID, expiresAt)
return s.User(ctx, userID)
}
func (s *Store) RevokeSession(ctx context.Context, token string) error {
hash := sha256.Sum256([]byte(token))
if _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:]); err != nil {
return err
}
if s.rdb == nil {
return nil
}
var err error
for attempt := 1; attempt <= 3; attempt++ {
if err = s.cacheSessionDel(ctx, hash); err == nil {
return nil
}
s.log.Warn("redis DEL failed on logout, retrying", "attempt", attempt, "error", err.Error())
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("session cache invalidation failed after retries: %w", err)
}
// ─────────────── Чаты ───────────────
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string, callerID string) (*model.Chat, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback(ctx)
rows, err := tx.Query(ctx, `SELECT id FROM users WHERE id = ANY($1)`, memberIDs)
if err != nil {
return nil, err
}
found := make(map[string]bool, len(memberIDs))
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return nil, err
}
found[id] = true
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
if len(found) != len(memberIDs) {
return nil, ErrBadMembers
}
if !found[callerID] {
return nil, ErrBadMembers
}
chat := &model.Chat{ID: uuid.NewString(), Title: title, MemberIDs: memberIDs, CreatedAt: model.NowTS()}
if _, err := tx.Exec(ctx,
`INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`,
chat.ID, chat.Title, chat.CreatedAt.Time); err != nil {
return nil, err
}
if _, err := tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id) SELECT $1, unnest($2::uuid[])`,
chat.ID, memberIDs); err != nil {
return nil, err
}
if err := tx.Commit(ctx); err != nil {
return nil, err
}
return chat, nil
}
func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (*model.Chat, error) {
var c model.Chat
var createdAt time.Time
var members []string
err := s.pool.QueryRow(ctx,
`SELECT c.id, c.title, c.created_at, (SELECT array_agg(cm.user_id) FROM chat_members cm WHERE cm.chat_id = c.id) FROM chats c WHERE c.id = $1 AND EXISTS (SELECT 1 FROM chat_members cm WHERE cm.chat_id = c.id AND cm.user_id = $2)`,
chatID, userID).Scan(&c.ID, &c.Title, &createdAt, &members)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
c.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
c.MemberIDs = members
return &c, nil
}
func (s *Store) ListChats(ctx context.Context, userID string, limit int, cur *Cursor) ([]*model.Chat, bool, error) {
rows, err := s.pool.Query(ctx,
`SELECT c.id, c.title, c.created_at, array_agg(cm.user_id) FROM chats c JOIN chat_members cm ON cm.chat_id = c.id WHERE c.id IN (SELECT chat_id FROM chat_members WHERE user_id = $1) GROUP BY c.id ORDER BY c.created_at, c.id`, userID)
if err != nil {
return nil, false, err
}
defer rows.Close()
all := make([]*model.Chat, 0, 8)
for rows.Next() {
var c model.Chat
var createdAt time.Time
var members []string
if err := rows.Scan(&c.ID, &c.Title, &createdAt, &members); err != nil {
return nil, false, err
}
c.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
c.MemberIDs = members
all = append(all, &c)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
items, more := paginate(all, limit, cur, func(c *model.Chat) (time.Time, string) {
return c.CreatedAt.Time, c.ID
})
return items, more, nil
}
// ─────────────── Сообщения ───────────────
// CreateMessage — идемпотентная отправка сообщения (Lab 3) + привязка вложений (Lab 4).
// Область идемпотентности: (chat_id, sender_id, idempotency_key).
// attachmentIDs проверяются на принадлежность чату в той же транзакции.
func (s *Store) CreateMessage(
ctx context.Context,
chatID, senderID, text string,
attachmentIDs []string,
idempotencyKey string,
) (*model.Message, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback(ctx)
// 1. Проверка членства в чате
var one int
err = tx.QueryRow(ctx,
`SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`,
chatID, senderID).Scan(&one)
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
// 2. Проверка принадлежности вложений ЭТОМУ чату.
// Все вложения должны существовать и принадлежать chatID; чужое/неизвестное — 404.
if len(attachmentIDs) > 0 {
rows, err := tx.Query(ctx,
`SELECT id FROM attachments WHERE id = ANY($1) AND chat_id = $2`,
attachmentIDs, chatID)
if err != nil {
return nil, err
}
found := make(map[string]bool, len(attachmentIDs))
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return nil, err
}
found[id] = true
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, err
}
if len(found) != len(attachmentIDs) {
return nil, ErrNotFound
}
}
// 3. Пытаемся вставить сообщение. Если ключ уже есть — игнорируем (DO NOTHING)
m := &model.Message{
ID: uuid.NewString(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: model.NowTS(),
AttachmentIDs: attachmentIDs,
}
var insertedID string
err = tx.QueryRow(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at, idempotency_key, attachment_ids)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (chat_id, sender_id, idempotency_key) DO NOTHING
RETURNING id
`, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt.Time, idempotencyKey, attachmentIDs).Scan(&insertedID)
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
return nil, err
}
// 4. Если вернулось ErrNoRows, значит сработал ON CONFLICT DO NOTHING
if errors.Is(err, pgx.ErrNoRows) {
var existing model.Message
var createdAt time.Time
var existingAttIDs []string
err = tx.QueryRow(ctx, `
SELECT id, chat_id, sender_id, text, created_at, attachment_ids
FROM messages
WHERE chat_id = $1 AND sender_id = $2 AND idempotency_key = $3
`, chatID, senderID, idempotencyKey).Scan(
&existing.ID, &existing.ChatID, &existing.SenderID, &existing.Text, &createdAt, &existingAttIDs)
if err != nil {
return nil, err
}
// Сравниваем тело (текст + вложения). Любое отличие — конфликт 409.
if existing.Text != text || !sameStringSet(existingAttIDs, attachmentIDs) {
return nil, ErrIdempotencyConflict
}
existing.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
existing.AttachmentIDs = existingAttIDs
if err := tx.Commit(ctx); err != nil {
return nil, err
}
return &existing, nil
}
// 5. Успешная вставка
if err := tx.Commit(ctx); err != nil {
return nil, err
}
if s.cacheMode == "versioned" {
s.bumpChatVersion(ctx, chatID)
}
return m, nil
}
// sameStringSet — сравнение двух срезов строк как множеств.
func sameStringSet(a, b []string) bool {
if len(a) != len(b) {
return false
}
m := make(map[string]struct{}, len(a))
for _, v := range a {
m[v] = struct{}{}
}
for _, v := range b {
if _, ok := m[v]; !ok {
return false
}
}
return true
}
func (s *Store) ListMessages(ctx context.Context, chatID string, limit int, cur *Cursor) ([]*model.Message, bool, error) {
cursorJSON := EncodeCursorJSON(cur)
useCache := s.rdb != nil && s.cacheMode != "off"
version := int64(0)
if useCache && s.cacheMode == "versioned" {
version = s.ChatVersion(ctx, chatID)
}
key := HistoryCacheKey(chatID, version, cursorJSON, limit)
if useCache {
if items, hasMore, ok := s.CacheHistoryGet(ctx, key); ok {
s.log.Info("cache_hit", "chat_id", chatID, "mode", s.cacheMode, "cursor", cursorJSON)
return items, hasMore, nil
}
}
type pageResult struct {
items []*model.Message
hasMore bool
}
fetch := func() (any, error) {
s.log.Info("sql_list_messages", "chat_id", chatID, "cursor", cursorJSON, "limit", limit)
q := `SELECT id, chat_id, sender_id, text, created_at, attachment_ids FROM messages WHERE chat_id = $1`
args := []any{chatID}
if cur != nil {
q += ` AND (created_at, id) > ($2, $3)`
args = append(args, cur.TS, cur.ID)
}
q += ` ORDER BY created_at, id LIMIT $` + strconv.Itoa(len(args)+1)
args = append(args, limit+1)
rows, err := s.pool.Query(ctx, q, args...)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]*model.Message, 0, limit)
for rows.Next() {
var m model.Message
var createdAt time.Time
var attIDs []string
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt, &attIDs); err != nil {
return nil, err
}
m.CreatedAt = model.Timestamp{Time: createdAt.UTC()}
if attIDs == nil {
attIDs = []string{}
}
m.AttachmentIDs = attIDs
items = append(items, &m)
}
if err := rows.Err(); err != nil {
return nil, err
}
more := len(items) > limit
if more {
items = items[:limit]
}
return pageResult{items: items, hasMore: more}, nil
}
var res any
var err error
if useCache && s.cacheMode == "versioned" {
res, err = s.sf.Do(key, fetch)
} else {
res, err = fetch()
}
if err != nil {
return nil, false, err
}
pr := res.(pageResult)
if useCache {
s.CacheHistoryPut(ctx, key, pr.items, pr.hasMore)
}
return pr.items, pr.hasMore, nil
}
// ─────────────── Вложения (лаба 4) ───────────────
// CreateAttachment — вставка метаданных в БД. Вызывается после успешного
// PUT в S3. При ошибке хендлер компенсирует — удаляет объект из S3.
func (s *Store) CreateAttachment(ctx context.Context, att *model.Attachment) error {
_, err := s.pool.Exec(ctx, `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256, s3_key, status, error_code, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
`,
att.ID, att.ChatID, att.OwnerID, att.Filename, att.ContentType,
att.SizeBytes, att.SHA256, att.S3Key, att.Status, att.ErrorCode,
att.CreatedAt.Time, att.UpdatedAt.Time)
if err != nil {
return err
}
return nil
}
// GetAttachmentForUser — метаданные вложения с проверкой членства в чате.
// Посторонний получает ErrNotFound (404) — не раскрываем существование объекта.
// GetAttachmentForUser — метаданные вложения с проверкой членства в чате.
// Посторонний получает ErrNotFound (404) — не раскрываем существование объекта.
// LAB 5: возвращает фактические status/variants/error_code через общий scanAttachment,
// чтобы список колонок был в одном месте (attachCols) и не разъезжался с воркером.
func (s *Store) GetAttachmentForUser(ctx context.Context, attachmentID, userID string) (*model.Attachment, error) {
return scanAttachment(s.pool.QueryRow(ctx, `SELECT`+attachCols+`
FROM attachments a
WHERE a.id = $1
AND EXISTS (
SELECT 1 FROM chat_members cm
WHERE cm.chat_id = a.chat_id AND cm.user_id = $2
)`, attachmentID, userID))
}
// ValidateAttachmentsForChat — проверка, что все attachmentIDs существуют и
// принадлежат именно этому чату. Вызывается перед сохранением сообщения.
// Если хоть один ID не прошёл — ErrNotFound (чужой объект = как будто нет).
func (s *Store) ValidateAttachmentsForChat(ctx context.Context, chatID string, ids []string) error {
if len(ids) == 0 {
return nil
}
rows, err := s.pool.Query(ctx,
`SELECT id FROM attachments WHERE id = ANY($1) AND chat_id = $2`,
ids, chatID)
if err != nil {
return err
}
defer rows.Close()
found := make(map[string]bool, len(ids))
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return err
}
found[id] = true
}
if err := rows.Err(); err != nil {
return err
}
if len(found) != len(ids) {
return ErrNotFound
}
return nil
}
// ─────────────── Делегаты S3 (лаба 4) ───────────────
// PutObject — кладёт байты в приватный S3-бакет.
// Ошибки маппятся хендлером в 503 через IsS3Unavailable.
func (s *Store) PutObject(ctx context.Context, key string, data []byte, contentType string) error {
if s.s3 == nil {
return errors.New("s3 client not configured")
}
return s.s3.PutObject(ctx, key, data, contentType)
}
// GetObject — скачивает байты из S3.
func (s *Store) GetObject(ctx context.Context, key string) ([]byte, error) {
if s.s3 == nil {
return nil, errors.New("s3 client not configured")
}
return s.s3.GetObject(ctx, key)
}
// DeleteObject — удаляет объект. Используется для компенсации, если INSERT
// метаданных в БД упал после успешного S3 PUT.
func (s *Store) DeleteObject(ctx context.Context, key string) error {
if s.s3 == nil {
return nil
}
return s.s3.DeleteObject(ctx, key)
}
// IsUnavailable — «БД недоступна» (пул закрыт, таймаут, ошибка подключения).
func IsUnavailable(err error) bool {
if err == nil {
return false
}
var connErr *pgconn.ConnectError
var netErr net.Error
if errors.As(err, &connErr) {
return true
}
if errors.As(err, &netErr) && netErr.Timeout() {
return true
}
errStr := err.Error()
return strings.Contains(errStr, "connection refused") ||
strings.Contains(errStr, "connection reset") ||
strings.Contains(errStr, "pool closed") ||
strings.Contains(errStr, "acquire timeout") ||
strings.Contains(errStr, "no connection")
}
+113
View File
@@ -0,0 +1,113 @@
// Package store, queue.go — брокер Redis Streams для заданий обработки (лаба 5).
//
// Почему Redis Streams, а не Pub/Sub: поток хранит сообщения (durable при AOF),
// consumer group даёт at-least-once доставку и явный ack, XAUTOCLAIM возвращает
// сообщения упавшего потребителя. В очередь идут только ID (jobs.schema.json).
package store
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"strings"
"time"
"github.com/redis/go-redis/v9"
"mtusi-messenger/internal/model"
)
const (
// QueueStreamKey — имя потока заданий.
QueueStreamKey = "messenger:attachment-jobs"
// QueueGroup — consumer group worker'ов.
QueueGroup = "workers"
// queueMaxLen — приблизительный потолок длины потока (защита от разрастания).
queueMaxLen = 10000
)
// Queue — обёртка над Redis Streams.
type Queue struct {
rdb *redis.Client
log *slog.Logger
}
func NewQueue(rdb *redis.Client, log *slog.Logger) *Queue {
return &Queue{rdb: rdb, log: log}
}
// Ensure — идемпотентное создание потока и consumer group.
func (q *Queue) Ensure(ctx context.Context) error {
err := q.rdb.XGroupCreateMkStream(ctx, QueueStreamKey, QueueGroup, "0").Err()
if err != nil && !strings.Contains(err.Error(), "BUSYGROUP") {
return fmt.Errorf("create consumer group: %w", err)
}
return nil
}
// Publish — добавить сообщение в поток (publisher confirm = успех XADD).
func (q *Queue) Publish(ctx context.Context, msg model.JobMessage) (string, error) {
b, err := json.Marshal(msg)
if err != nil {
return "", fmt.Errorf("marshal job message: %w", err)
}
id, err := q.rdb.XAdd(ctx, &redis.XAddArgs{
Stream: QueueStreamKey,
MaxLen: queueMaxLen,
Approx: true,
Values: map[string]any{"payload": string(b)},
}).Result()
if err != nil {
return "", fmt.Errorf("xadd: %w", err)
}
return id, nil
}
// Consume — читать новые сообщения группы (BLOCK, COUNT 1: ограниченный prefetch).
func (q *Queue) Consume(ctx context.Context, consumer string, block time.Duration) ([]redis.XMessage, error) {
res, err := q.rdb.XReadGroup(ctx, &redis.XReadGroupArgs{
Group: QueueGroup,
Consumer: consumer,
Streams: []string{QueueStreamKey, ">"},
Count: 1,
Block: block,
}).Result()
if err == redis.Nil {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("xreadgroup: %w", err)
}
var out []redis.XMessage
for _, s := range res {
out = append(out, s.Messages...)
}
return out, nil
}
// Ack — подтвердить устойчивую обработку (после COMMIT результата в БД).
func (q *Queue) Ack(ctx context.Context, msgID string) error {
return q.rdb.XAck(ctx, QueueStreamKey, QueueGroup, msgID).Err()
}
// ReclaimStale — забрать сообщения, которые держит упавший потребитель
// (minIdle больше lease TTL, чтобы не перехватывать живую долгую обработку).
// Второе возвращаемое значение XAutoClaim — курсор следующей страницы PEL;
// мы его игнорируем, потому что периодический цикл воркера сканирует PEL
// с начала ("0-0") малыми порциями (Count), и очередь зависших сообщений
// дренируется за несколько циклов.
func (q *Queue) ReclaimStale(ctx context.Context, consumer string, minIdle time.Duration) ([]redis.XMessage, error) {
msgs, _, err := q.rdb.XAutoClaim(ctx, &redis.XAutoClaimArgs{
Stream: QueueStreamKey,
Group: QueueGroup,
Consumer: consumer,
MinIdle: minIdle,
Start: "0-0",
Count: 4,
}).Result()
if err != nil {
return nil, fmt.Errorf("xautoclaim: %w", err)
}
return msgs, nil
}
+109
View File
@@ -0,0 +1,109 @@
package store
import (
"context"
"fmt"
"log/slog"
"strings"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
// attachmentIDFromKey — извлекает attachment_id из object key лабы 5.
// Форматы: staging/{chat}/{att} и {chat}/{att}/{variant|original}.
func attachmentIDFromKey(key string) (string, bool) {
parts := strings.Split(key, "/")
if len(parts) != 3 {
return "", false
}
if parts[0] == "staging" {
return parts[2], true
}
return parts[1], true
}
// RunReconcile — сверка S3 ↔ PostgreSQL (лаба 5).
//
// Известным считается объект, чей attachment_id присутствует в таблице
// attachments (независимо от статуса). Исключение: staging-объект вложения
// в терминальном failed — он больше не нужен и удаляется.
//
// Осиротевшие объекты (attachment_id отсутствует в БД) удаляются только старше
// grace period: это защищает гонку «объект создан, метаданные дописываются».
func RunReconcile(ctx context.Context, pool *pgxpool.Pool, s3 *S3Client, grace time.Duration, log *slog.Logger) error {
if s3 == nil {
return fmt.Errorf("reconcile: s3 client not configured")
}
rows, err := pool.Query(ctx, `SELECT id, status FROM attachments`)
if err != nil {
return fmt.Errorf("reconcile: query attachments: %w", err)
}
known := make(map[string]string)
for rows.Next() {
var id, status string
if err := rows.Scan(&id, &status); err != nil {
rows.Close()
return fmt.Errorf("reconcile: scan: %w", err)
}
known[id] = status
}
rows.Close()
if err := rows.Err(); err != nil {
return fmt.Errorf("reconcile: rows err: %w", err)
}
objs, err := s3.ListObjectsInfo(ctx, "")
if err != nil {
return fmt.Errorf("reconcile: list objects: %w", err)
}
now := time.Now().UTC()
var deleted, skippedYoung, skippedUnknown int
for _, o := range objs {
attID, ok := attachmentIDFromKey(o.Key)
if !ok {
skippedUnknown++
log.Info("reconcile skip unknown key format", "key", o.Key)
continue
}
status, inDB := known[attID]
if inDB {
// staging у failed-вложения больше не нужен.
if status == "failed" && strings.HasPrefix(o.Key, "staging/") {
if err := s3.DeleteObject(ctx, o.Key); err != nil {
log.Warn("reconcile delete failed staging", "key", o.Key, "error", err.Error())
continue
}
deleted++
log.Info("reconcile deleted failed staging", "key", o.Key)
}
continue
}
age := now.Sub(o.LastModified.UTC())
if age < grace {
skippedYoung++
log.Info("reconcile skip young orphan",
"key", o.Key,
"age_seconds", int(age.Seconds()),
"grace_seconds", int(grace.Seconds()))
continue
}
if err := s3.DeleteObject(ctx, o.Key); err != nil {
log.Warn("reconcile delete failed", "key", o.Key, "error", err.Error())
continue
}
deleted++
log.Info("reconcile deleted orphan", "key", o.Key, "age_seconds", int(age.Seconds()))
}
log.Info("reconcile complete",
"objects_in_bucket", len(objs),
"known_attachments", len(known),
"deleted", deleted,
"skipped_young", skippedYoung,
"skipped_unknown_format", skippedUnknown,
"grace_seconds", int(grace.Seconds()))
return nil
}
+184
View File
@@ -0,0 +1,184 @@
// Package store, s3.go — клиент приватного S3-совместимого хранилища (лаба 4).
//
// Разделение данных:
// - Источник истины для БАЙТОВ — это хранилище.
// - Источник истины для МЕТАДАННЫХ — PostgreSQL (таблица attachments).
//
// Ключ объекта (s3_key) назначает сервер и НЕ раскрывает клиенту.
// Бакет приватный: анонимного доступа нет, скачивание только через
// авторизованный API с проверкой членства в чате. Приватный бакет сам по себе
// НЕ заменяет эту проверку (см. handlers.go).
package store
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log/slog"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
// s3Timeout — максимальное время на одну операцию с хранилищем.
// При недоступном хранилище клиент быстро получает ошибку, и загрузка/скачивание
// честно возвращают 503, а не висят до таймаута клиента.
const s3Timeout = 30 * time.Second
// S3Client — обёртка над MinIO/S3 с фиксированным приватным бакетом.
type S3Client struct {
client *minio.Client
bucket string
log *slog.Logger
}
// NewS3Client создаёт клиент.
// - endpoint: "host:port" без схемы, например "minio:9000";
// - useSSL: false для локального стенда по HTTP.
//
// Уровень 4: "API использует отдельные S3 credentials с ограниченными правами".
// Эти креды читаются из переменных окружения (см. main.go, compose.yaml) и не
// коммитятся в репозиторий.
func NewS3Client(endpoint, accessKey, secretKey, bucket string, useSSL bool, log *slog.Logger) (*S3Client, error) {
c, err := minio.New(endpoint, &minio.Options{
Creds: credentials.NewStaticV4(accessKey, secretKey, ""),
Secure: useSSL,
BucketLookup: minio.BucketLookupPath,
Region: "us-east-1",
})
if err != nil {
return nil, fmt.Errorf("init s3 client: %w", err)
}
return &S3Client{client: c, bucket: bucket, log: log}, nil
}
// EnsureBucket — идемпотентный бутстрап приватного бакета.
// Вызывается при старте; повторный вызов безопасен (существующий бакет не
// пересоздаётся). Уровень 4: "Bucket bootstrap идемпотентен".
func (s *S3Client) EnsureBucket(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
ok, err := s.client.BucketExists(ctx, s.bucket)
if err != nil {
return fmt.Errorf("check bucket: %w", err)
}
if ok {
s.log.Info("s3 bucket already exists", "bucket", s.bucket)
return nil
}
if err := s.client.MakeBucket(ctx, s.bucket, minio.MakeBucketOptions{}); err != nil {
return fmt.Errorf("create bucket: %w", err)
}
s.log.Info("s3 bucket created", "bucket", s.bucket)
return nil
}
// PutObject — положить байты в бакет. Используется в загрузке вложения.
// Ошибка маппится хендлером в 503 (хранилище недоступно).
func (s *S3Client) PutObject(ctx context.Context, key string, data []byte, contentType string) error {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
_, err := s.client.PutObject(ctx, s.bucket, key, bytes.NewReader(data), int64(len(data)), minio.PutObjectOptions{
ContentType: contentType,
})
if err != nil {
return fmt.Errorf("s3 put object: %w", err)
}
return nil
}
// GetObject — скачать байты. Используется в скачивании вложения.
// Сначала проверяем существование (чтобы отличить "объект не найден" от сетевой
// ошибки), затем читаем. Ошибка маппится хендлером в 503 или 404.
func (s *S3Client) GetObject(ctx context.Context, key string) ([]byte, error) {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
if _, err := s.client.StatObject(ctx, s.bucket, key, minio.StatObjectOptions{}); err != nil {
return nil, fmt.Errorf("s3 stat object: %w", err)
}
obj, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, fmt.Errorf("s3 get object: %w", err)
}
defer obj.Close()
data, err := io.ReadAll(obj)
if err != nil {
return nil, fmt.Errorf("s3 read object: %w", err)
}
return data, nil
}
// DeleteObject — удалить объект. Используется для компенсации, если запись
// метаданных в БД не удалась после успешного S3 PUT (механизм согласованности
// уровня 4), а также в reconciler для очистки осиротевших объектов.
func (s *S3Client) DeleteObject(ctx context.Context, key string) error {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
if err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{}); err != nil {
return fmt.Errorf("s3 delete object: %w", err)
}
return nil
}
// ListKeys — перечислить все ключи объектов с префиксом ("" = все).
// Используется в reconciler (уровень 4) для поиска осиротевших объектов:
// объектов в хранилище, у которых нет метаданных в БД.
// Результат ограничен по времени (см. context.WithTimeout), но НЕ по количеству —
// для учебной лабы этого достаточно; в отчёте зафиксируешь ограничение.
func (s *S3Client) ListKeys(ctx context.Context, prefix string) ([]string, error) {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
var keys []string
for obj := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
if obj.Err != nil {
return nil, fmt.Errorf("s3 list objects: %w", obj.Err)
}
keys = append(keys, obj.Key)
}
return keys, nil
}
// IsS3Unavailable — эвристика "хранилище недоступно" для маппинга в 503.
// Аналог IsUnavailable для PostgreSQL: сетевые ошибки и таймауты считаем
// недоступностью, а не ошибкой клиента.
func IsS3Unavailable(err error) bool {
if err == nil {
return false
}
if errors.Is(err, context.DeadlineExceeded) {
return true
}
msg := err.Error()
return strings.Contains(msg, "connection refused") ||
strings.Contains(msg, "connection reset") ||
strings.Contains(msg, "no such host") ||
strings.Contains(msg, "timeout") ||
strings.Contains(msg, "i/o timeout") ||
strings.Contains(msg, "dial tcp")
}
// ObjectInfo — ключ и время изменения объекта. Нужно reconcile, чтобы
// отличать «осиротевший давно» от «создан секунду назад, метаданные дописываются».
type ObjectInfo struct {
Key string
LastModified time.Time
}
// ListObjectsInfo — перечислить объекты с ключом и временем изменения.
// Используется RunReconcile (уровень 4) для поиска осиротевших объектов.
func (s *S3Client) ListObjectsInfo(ctx context.Context, prefix string) ([]ObjectInfo, error) {
ctx, cancel := context.WithTimeout(ctx, s3Timeout)
defer cancel()
var out []ObjectInfo
for obj := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
if obj.Err != nil {
return nil, fmt.Errorf("s3 list objects: %w", obj.Err)
}
out = append(out, ObjectInfo{Key: obj.Key, LastModified: obj.LastModified})
}
return out, nil
}
+120
View File
@@ -0,0 +1,120 @@
// Package worker, pipeline.go — генерация вариантов изображения (лаба 5).
//
// thumbnail : JPEG, вписан в 256x256 БЕЗ увеличения, EXIF orientation учтён,
//
// альфа-канал сведён на белый фон.
//
// crop : JPEG, центральный квадрат 128x128 (для малых изображений
//
// допускается увеличение, иначе квадрат не собрать).
//
// optimized : WebP, вписан в 1280x1280 БЕЗ увеличения, EXIF не сохраняется.
//
// Память ограничена потолком пикселей (40 Мп), время — дедлайном задания
// в worker.go. Декодирование одно, варианты строятся из одного кадра.
package worker
import (
"bytes"
"errors"
"image"
"image/color"
"image/draw"
"io"
"github.com/disintegration/imaging"
)
const (
thumbMax = 256
cropSize = 128
optMax = 1280
jpegQuality = 80
webpQuality = 80
maxPixels = 40_000_000
)
var errTooManyPixels = errors.New("image exceeds pixel limit")
// variantOut — готовый байтовый вариант с фактическими размерми.
type variantOut struct {
Name string
ContentType string
Data []byte
Width int
Height int
}
// buildVariants декодирует оригинал один раз и строит три варианта.
func buildVariants(src io.Reader) ([]variantOut, error) {
img, err := imaging.Decode(src, imaging.AutoOrientation(true))
if err != nil {
return nil, err
}
b := img.Bounds()
if int64(b.Dx())*int64(b.Dy()) > maxPixels {
return nil, errTooManyPixels
}
out := make([]variantOut, 0, 3)
// thumbnail
thumb := fitNoUpscale(img, thumbMax, thumbMax)
thumb = flattenOnWhite(thumb)
buf := &bytes.Buffer{}
if err := imaging.Encode(buf, thumb, imaging.JPEG, imaging.JPEGQuality(jpegQuality)); err != nil {
return nil, err
}
out = append(out, variantOut{
Name: "thumbnail", ContentType: "image/jpeg",
Data: buf.Bytes(), Width: thumb.Bounds().Dx(), Height: thumb.Bounds().Dy(),
})
// crop
side := b.Dx()
if b.Dy() < side {
side = b.Dy()
}
square := imaging.CropCenter(img, side, side)
cropped := flattenOnWhite(imaging.Resize(square, cropSize, cropSize, imaging.Lanczos))
buf = &bytes.Buffer{}
if err := imaging.Encode(buf, cropped, imaging.JPEG, imaging.JPEGQuality(jpegQuality)); err != nil {
return nil, err
}
out = append(out, variantOut{
Name: "crop", ContentType: "image/jpeg",
Data: buf.Bytes(), Width: cropSize, Height: cropSize,
})
// optimized
opt := fitNoUpscale(img, optMax, optMax)
buf = &bytes.Buffer{}
if err := encodeWebp(buf, opt, webpQuality); err != nil {
return nil, err
}
out = append(out, variantOut{
Name: "optimized", ContentType: "image/webp",
Data: buf.Bytes(), Width: opt.Bounds().Dx(), Height: opt.Bounds().Dy(),
})
return out, nil
}
// fitNoUpscale вписывает в бокс, но никогда не увеличивает малые изображения.
func fitNoUpscale(img image.Image, mw, mh int) image.Image {
b := img.Bounds()
if b.Dx() <= mw && b.Dy() <= mh {
return img
}
return imaging.Fit(img, mw, mh, imaging.Lanczos)
}
// flattenOnWhite сводит альфа-канал на белый фон.
func flattenOnWhite(img image.Image) image.Image {
b := img.Bounds()
white := image.NewRGBA(b)
draw.Draw(white, b, image.NewUniform(color.White), image.Point{}, draw.Src)
draw.Draw(white, b, img, b.Min, draw.Over)
return white
}
+15
View File
@@ -0,0 +1,15 @@
//go:build cgo
package worker
import (
"image"
"io"
"github.com/chai2010/webp"
)
// encodeWebp — lossy WebP через libwebp (только в cgo-сборке, т.е. в Docker).
func encodeWebp(w io.Writer, img image.Image, quality float32) error {
return webp.Encode(w, img, &webp.Options{Lossless: false, Quality: quality})
}
+15
View File
@@ -0,0 +1,15 @@
//go:build !cgo
package worker
import (
"errors"
"image"
"io"
)
// encodeWebp — заглушка для локальных сборок без cgo.
// Воркер выполняется только в Docker, где cgo включён.
func encodeWebp(w io.Writer, img image.Image, quality float32) error {
return errors.New("webp encoding requires cgo build (run inside Docker)")
}
+267
View File
@@ -0,0 +1,267 @@
// Package worker, worker.go — цикл обработки заданий (лаба 5).
//
// consume -> claim(lease) -> process -> complete/fail/retry -> ack.
// ack только ПОСЛЕ COMMIT результата в БД (at-least-once без потери эффекта).
// Упавшего потребителя подхватывает XAUTOCLAIM; зависшую аренду снимает
// ReapExpiredLeases. Отложенные повторы публикует EnqueueDueRetries — он
// соблюдает next_attempt_at, иначе Redis Streams (у которого нет встроенной
// отложенной доставки) съел бы retry мгновенно.
// Повторная доставка безопасна: claim-гард не даст второму воркеру
// пересоздать варианты готового вложения.
package worker
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"log/slog"
"math"
"math/rand"
"time"
"github.com/google/uuid"
"github.com/redis/go-redis/v9"
"mtusi-messenger/internal/model"
"mtusi-messenger/internal/store"
)
const (
jobTimeout = 60 * time.Second // лимит времени одной обработки
consumeBlock = 2 * time.Second
reclaimIdle = store.LeaseTTL + 30*time.Second // не перехватывать живую обработку
housekeepEvery = 5 * time.Second
backoffBase = 500 * time.Millisecond
backoffCap = 8 * time.Second
)
// Worker — потребитель очереди заданий.
type Worker struct {
st *store.Store
q *store.Queue
log *slog.Logger
name string
}
func New(st *store.Store, q *store.Queue, log *slog.Logger) *Worker {
return &Worker{st: st, q: q, log: log, name: "worker-" + uuid.NewString()[:8]}
}
// Run — основной цикл. Завершается по отмене контекста (graceful stop).
func (w *Worker) Run(ctx context.Context) error {
if err := w.q.Ensure(ctx); err != nil {
return err
}
w.log.Info("worker started", "consumer", w.name)
hk := time.NewTicker(housekeepEvery)
defer hk.Stop()
for {
select {
case <-ctx.Done():
w.log.Info("worker stopping")
return nil
case <-hk.C:
w.housekeep(ctx)
default:
}
msgs, err := w.q.Consume(ctx, w.name, consumeBlock)
if err != nil {
w.log.Warn("consume error", "error", err.Error())
select {
case <-ctx.Done():
return nil
case <-time.After(time.Second):
}
continue
}
for _, m := range msgs {
w.handle(ctx, m)
}
}
}
// housekeep — возврат сообщений упавших потребителей, снятие истёкших аренд
// и публикация отложенных повторов, у которых настал срок (next_attempt_at <= now).
func (w *Worker) housekeep(ctx context.Context) {
msgs, err := w.q.ReclaimStale(ctx, w.name, reclaimIdle)
if err == nil {
for _, m := range msgs {
w.handle(ctx, m)
}
} else {
w.log.Warn("reclaim stale", "error", err.Error())
}
n, err := w.st.ReapExpiredLeases(ctx)
if err != nil {
w.log.Warn("reap leases", "error", err.Error())
} else if n > 0 {
w.log.Info("reaped expired leases", "count", n)
}
d, err := w.st.EnqueueDueRetries(ctx)
if err != nil {
w.log.Warn("enqueue due retries", "error", err.Error())
} else if d > 0 {
w.log.Info("enqueued due retries", "count", d)
}
}
// handle — обработка одного сообщения очереди.
func (w *Worker) handle(parent context.Context, m redis.XMessage) {
raw, ok := m.Values["payload"].(string)
if !ok {
w.log.Error("message without payload", "id", m.ID)
_ = w.q.Ack(parent, m.ID) // нечитаемое сообщение не должно блокировать очередь
return
}
var msg model.JobMessage
if err := json.Unmarshal([]byte(raw), &msg); err != nil {
w.log.Error("bad job message", "id", m.ID, "error", err.Error())
_ = w.q.Ack(parent, m.ID)
return
}
ctx, cancel := context.WithTimeout(parent, jobTimeout)
defer cancel()
claim, err := w.st.ClaimJob(ctx, msg.JobID, msg.Attempt, uuid.NewString(), time.Now().Add(store.LeaseTTL))
if err != nil {
w.log.Warn("claim failed", "job", msg.JobID, "error", err.Error())
return // без ack: сообщение вернётся через PEL
}
if claim == nil {
// Либо терминальное состояние (повтор после готовности), либо живая аренда.
if att, aerr := w.st.GetAttachmentInternal(ctx, msg.AttachmentID); aerr == nil &&
(att.Status == model.StatusReady || att.Status == model.StatusFailed) {
_ = w.q.Ack(parent, m.ID) // идемпотентный no-op
}
return
}
perr := w.process(ctx, claim)
switch {
case perr == nil:
_ = w.q.Ack(parent, m.ID)
case isPermanent(perr):
// Терминальный отказ: staging больше не нужен, убираем best-effort.
if att, aerr := w.st.GetAttachmentInternal(parent, claim.AttachmentID); aerr == nil {
_ = w.st.DeleteObject(parent, store.StagingKey(att.ChatID, att.ID))
}
if ferr := w.st.FailJob(parent, claim.AttachmentID, errorCode(perr), perr.Error()); ferr != nil {
w.log.Warn("fail job persist", "error", ferr.Error())
return // без ack: попробуем ещё раз зафиксировать отказ
}
_ = w.q.Ack(parent, m.ID)
default: // временная ошибка: retry с backoff+jitter либо финальный отказ
if claim.Attempt < store.DefaultMaxAttempts {
next := time.Now().Add(backoff(claim.Attempt))
if ok, rerr := w.st.ScheduleRetry(parent, claim.AttachmentID, next, "transient_error"); rerr != nil || !ok {
w.log.Warn("schedule retry failed", "error", rerr)
}
} else {
_ = w.st.FailJob(parent, claim.AttachmentID, "retry_exhausted", perr.Error())
}
_ = w.q.Ack(parent, m.ID) // намерение о повторе уже durable в outbox
}
}
// process — конвейер: staging -> варианты -> финальные объекты -> COMMIT.
func (w *Worker) process(ctx context.Context, c *store.ClaimedJob) error {
att, err := w.st.GetAttachmentInternal(ctx, c.AttachmentID)
if err != nil {
return permanentErr{code: "attachment_missing", err: err}
}
stagingKey := store.StagingKey(att.ChatID, att.ID)
data, err := w.st.GetObject(ctx, stagingKey)
if err != nil {
return transientErr{err} // хранилище недоступно
}
if sum := sha256.Sum256(data); hex.EncodeToString(sum[:]) != att.SHA256 {
return permanentErr{code: "checksum_mismatch"}
}
vars, err := buildVariants(bytes.NewReader(data))
if err != nil {
return permanentErr{code: "invalid_image", err: err}
}
for _, v := range vars {
key := store.VariantKey(att.ChatID, att.ID, v.Name)
if err := w.st.PutObject(ctx, key, v.Data, v.ContentType); err != nil {
return transientErr{err}
}
}
// Финальный оригинал публикуется ПОСЛЕ вариантов.
if err := w.st.PutObject(ctx, att.S3Key, data, att.ContentType); err != nil {
return transientErr{err}
}
mvars := make([]model.Variant, 0, len(vars))
for _, v := range vars {
s := sha256.Sum256(v.Data)
mvars = append(mvars, model.Variant{
Name: v.Name, ContentType: v.ContentType,
SizeBytes: int64(len(v.Data)), Width: v.Width, Height: v.Height,
SHA256: hex.EncodeToString(s[:]),
})
}
if err := w.st.CompleteJob(ctx, att.ID, mvars); err != nil {
return transientErr{err}
}
// Staging удаляется ТОЛЬКО после COMMIT результата.
_ = w.st.DeleteObject(ctx, stagingKey)
w.log.Info("job completed", "attachment", att.ID, "attempt", c.Attempt)
return nil
}
// ─────────────── классификация ошибок и backoff ───────────────
type permanentErr struct {
code string
err error
}
func (e permanentErr) Error() string {
if e.err != nil {
return e.code + ": " + e.err.Error()
}
return e.code
}
type transientErr struct{ err error }
func (e transientErr) Error() string { return "transient: " + e.err.Error() }
func isPermanent(err error) bool {
var p permanentErr
return errors.As(err, &p)
}
func errorCode(err error) string {
var p permanentErr
if errors.As(err, &p) {
return p.code
}
return "processing_error"
}
// backoff — экспоненциальная задержка с потолком и jitter ±25%,
// чтобы повторы не выстраивались в синхронную волну.
func backoff(attempt int) time.Duration {
d := float64(backoffBase) * math.Pow(2, float64(attempt-1))
if d > float64(backoffCap) {
d = float64(backoffCap)
}
jitter := 0.75 + rand.Float64()*0.5
return time.Duration(d * jitter)
}
+276
View File
@@ -0,0 +1,276 @@
#!/usr/bin/env python3
"""Track 1 bench: матрица нагрузка x размер истории для in-memory store.
Только stdlib. Пример:
python student-tests/bench.py --label before --container mtusi-messenger-lab1
"""
import argparse
import csv
import http.client
import json
import subprocess
import threading
import time
import uuid
class Client:
def __init__(self, host, port, user_id=None):
self.host, self.port, self.user_id = host, port, user_id
self.conn = None
def _ensure(self):
if self.conn is None:
self.conn = http.client.HTTPConnection(self.host, self.port, timeout=30)
def request(self, method, path, body=None):
headers = {}
data = None
if body is not None:
headers["Content-Type"] = "application/json"
data = json.dumps(body).encode()
if self.user_id:
headers["X-User-Id"] = self.user_id
for attempt in (0, 1):
try:
self._ensure()
self.conn.request(method, path, body=data, headers=headers)
resp = self.conn.getresponse()
payload = resp.read()
return resp.status, (json.loads(payload) if payload else None)
except Exception:
self.conn = None
if attempt:
raise
time.sleep(0.05)
class Phase:
def __init__(self):
self.lock = threading.Lock()
self.lat = []
self.errors = 0
self.requests = 0
def add(self, ms, ok):
with self.lock:
self.lat.append(ms)
self.requests += 1
if not ok:
self.errors += 1
def row(self):
with self.lock:
lat = sorted(self.lat)
n = len(lat)
if n == 0:
return 0, 0, 0, 0
def p(q):
return lat[min(n - 1, int((q * n) // 100))]
return n, p(50), p(95), p(99)
class RssSampler:
def __init__(self, container, interval=2.0):
self.container, self.interval = container, interval
self.samples = []
self.stop = threading.Event()
self.th = threading.Thread(target=self._run, daemon=True)
def _run(self):
while not self.stop.is_set():
try:
out = subprocess.run(
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", self.container],
capture_output=True, text=True, timeout=10).stdout.strip().splitlines()
if out:
self.samples.append(parse_mib(out[0].split("/")[0].strip()))
except Exception:
pass
self.stop.wait(self.interval)
def start(self):
self.th.start()
return self
def finish(self):
self.stop.set()
self.th.join(timeout=5)
if not self.samples:
return 0.0, 0.0
return sum(self.samples) / len(self.samples), max(self.samples)
def parse_mib(s):
s = s.strip()
if s.endswith("GiB"):
return float(s[:-3]) * 1024
if s.endswith("MiB"):
return float(s[:-3])
if s.endswith("KiB"):
return float(s[:-4]) / 1024
return 0.0
def run_phase(host, port, clients, duration, op):
ph = Phase()
deadline = time.perf_counter() + duration
def worker(idx):
c = Client(host, port, op_user(idx))
while time.perf_counter() < deadline:
t0 = time.perf_counter()
ok = op(c, idx)
ph.add((time.perf_counter() - t0) * 1000.0, ok)
threads = [threading.Thread(target=worker, args=(i,)) for i in range(clients)]
for t in threads:
t.start()
for t in threads:
t.join()
return ph
USERS = []
def op_user(idx):
return USERS[idx % len(USERS)]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--label", required=True)
ap.add_argument("--container", default="mtusi-messenger-lab1")
ap.add_argument("--sizes", default="10000,50000,150000")
ap.add_argument("--clients", default="8,32,96")
ap.add_argument("--duration", type=float, default=10.0)
ap.add_argument("--out", default="student-tests/results")
args = ap.parse_args()
hostport = args.base_url.split("://")[-1].split("/")
host, _, port = hostport[0].partition(":")
port = int(port or 80)
sizes = [int(x) for x in args.sizes.split(",")]
clients = [int(x) for x in args.clients.split(",")]
os_makedirs(args.out)
admin = Client(host, port)
global USERS
n_users = max(clients)
for i in range(n_users):
st, body = admin.request("POST", "/api/v1/users",
{"username": "b" + uuid.uuid4().hex[:12], "display_name": "Bench"})
assert st == 201, (st, body)
USERS.append(body["id"])
admin.user_id = USERS[0] # <-- ДОБАВИТЬ ЭТУ СТРОКУ: чаты создаёт участник
st, chat = admin.request("POST", "/api/v1/chats",
{"title": "bench", "member_ids": USERS})
assert st == 201, (st, chat)
chat_id = chat["id"]
st, chat2 = admin.request("POST", "/api/v1/chats",
{"title": "bench-writes", "member_ids": USERS})
assert st == 201
chat2_id = chat2["id"]
rows = []
have = 0
for H in sizes:
# досеиваем историю до H (кумулятивно, экономим время)
if H > have:
seed(host, port, chat_id, H - have)
have = H
for C in clients:
print(f"[{args.label}] read H={H} C={C} ...", flush=True)
rss = RssSampler(args.container).start()
ph = run_phase(host, port, C, args.duration, make_read_op(chat_id))
avg, mx = rss.finish()
n, p50, p95, p99 = ph.row()
rows.append([args.label, "read", H, C, args.duration, n, ph.errors,
round(n / args.duration, 1), p50, p95, p99, round(avg, 1), round(mx, 1)])
for C in clients:
print(f"[{args.label}] write C={C} ...", flush=True)
rss = RssSampler(args.container).start()
ph = run_phase(host, port, C, args.duration, make_write_op(chat2_id))
avg, mx = rss.finish()
n, p50, p95, p99 = ph.row()
rows.append([args.label, "write", 0, C, args.duration, n, ph.errors,
round(n / args.duration, 1), p50, p95, p99, round(avg, 1), round(mx, 1)])
path = f"{args.out}/{args.label}.csv"
with open(path, "w", newline="", encoding="utf-8") as f:
w = csv.writer(f)
w.writerow(["label", "phase", "history", "clients", "duration_s", "requests",
"errors", "rps", "p50_ms", "p95_ms", "p99_ms", "rss_avg_mib", "rss_max_mib"])
w.writerows(rows)
print(f"saved {path}")
def os_makedirs(p):
import os
os.makedirs(p, exist_ok=True)
def seed(host, port, chat_id, count):
threads_n = 16
per = count // threads_n
lock = threading.Lock()
state = {"done": 0, "errors": 0}
t0 = time.perf_counter()
def worker(idx):
c = Client(host, port, USERS[0])
for j in range(per):
st, _ = c.request("POST", f"/api/v1/chats/{chat_id}/messages",
{"text": f"seed-{idx}-{j}"})
with lock:
state["done"] += 1
if st != 201:
state["errors"] += 1
threads = [threading.Thread(target=worker, args=(i,)) for i in range(threads_n)]
for t in threads:
t.start()
for t in threads:
t.join()
dt = time.perf_counter() - t0
print(f" seeded {state['done']} msgs in {dt:.1f}s "
f"({state['done']/dt:.0f} rps, errors={state['errors']})", flush=True)
def make_read_op(chat_id):
cursors = {}
def op(c, idx):
cur = cursors.get(idx)
path = f"/api/v1/chats/{chat_id}/messages?limit=50"
if cur:
path += "&cursor=" + cur
st, body = c.request("GET", path)
if st != 200:
cursors[idx] = None
return False
cursors[idx] = body.get("next_cursor")
return True
return op
def make_write_op(chat_id):
counter = {"i": 0}
lock = threading.Lock()
def op(c, idx):
with lock:
counter["i"] += 1
i = counter["i"]
st, _ = c.request("POST", f"/api/v1/chats/{chat_id}/messages", {"text": f"w{i}"})
return st == 201
return op
if __name__ == "__main__":
main()
+229
View File
@@ -0,0 +1,229 @@
#!/usr/bin/env python3
"""Трек 5: согласованность кэша истории. Фазы (переключаются bat-ом через CACHE_MODE):
off — baseline: кэша нет. 32 конкурентных холодных чтения = ~32 SQL
(демонстрация cache stampede «до»), 100 последовательных чтений = 100 SQL,
latency p50/p95/p99 «до».
naive — кэш БЕЗ инвалидации версией: ожидаем НАБЛЮДАТЬ stale read
(запись не видна из тёплого кэша). Это демонстрация проблемы согласованности.
versioned — защищённый кэш: read-after-write OK; 32 конкурентных холодных чтения
схлопываются single-flight'ом в 1 SQL (защита от stampede «после»);
100 тёплых чтений обслуживает кэш (sql<=2), latency «после».
recovery — restart redis: сессия и read-after-write корректны, кэш перестраивается.
Запуск: scripts/cache_demo.bat (сам переключает CACHE_MODE и перезапускает api).
"""
import argparse
import base64
import json
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
FAILURES = []
BASE = "http://localhost:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
READS = 100 # последовательных чтений для SQL-счётчика и latency
STAMPEDE = 32 # конкурентных холодных чтений
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 sh(cmd):
subprocess.run(cmd, shell=True, check=True, capture_output=True)
def req(method, path, body=None, token=None, basic=None):
headers, data = {}, None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode()
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()
return resp.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read().decode()
try:
return e.code, json.loads(payload)
except ValueError:
return e.code, None
def wait_ready(timeout=90, want=200):
deadline = time.time() + timeout
while time.time() < deadline:
st, _ = req("GET", "/health/ready")
if st == want:
return True
time.sleep(1)
return False
def register_login():
uname = "t5" + uuid.uuid4().hex[:10]
st, _ = req("POST", "/api/v1/users", {"username": uname, "display_name": "T5", "password": PASSWORD})
assert st == 201, st
st, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}")
assert st == 201, st
return sess["token"], sess["user"]["id"]
def setup_chat(token, uid, n):
st, chat = req("POST", "/api/v1/chats",
{"title": "track5-" + uuid.uuid4().hex[:8], "member_ids": [uid]}, token=token)
assert st == 201, st
for i in range(n):
st, _ = req("POST", f"/api/v1/chats/{chat['id']}/messages",
{"text": f"t5-{i:03d}"}, token=token)
assert st == 201, st
return chat
def read_page(token, chat_id):
st, body = req("GET", f"/api/v1/chats/{chat_id}/messages?limit=50", token=token)
assert st == 200, (st, body)
return body
def sql_count(since_unix, chat_id):
out = subprocess.run(f"docker compose logs api --since {since_unix}",
shell=True, capture_output=True, text=True).stdout
return sum(1 for line in out.splitlines()
if "sql_list_messages" in line and chat_id in line)
def concurrent_burst(token, chat_id):
"""32 конкурентных холодных чтения через barrier; возвращает число SQL-запросов."""
since = str(int(time.time()))
barrier = threading.Barrier(STAMPEDE)
def reader():
barrier.wait()
read_page(token, chat_id)
ts = [threading.Thread(target=reader) for _ in range(STAMPEDE)]
for t in ts:
t.start()
for t in ts:
t.join()
return sql_count(since, chat_id)
def pctl(xs):
xs = sorted(xs)
n = len(xs)
def p(q):
return xs[min(n - 1, int(q * n // 100))]
return round(p(50), 2), round(p(95), 2), round(p(99), 2)
def phase_off():
token, uid = register_login()
chat = setup_chat(token, uid, 5)
# Stampede БЕЗ кэша: каждый из 32 конкурентных читателей идёт в SQL.
n_burst = concurrent_burst(token, chat["id"])
check("off: concurrent cold reads -> each hits SQL (stampede without cache)",
n_burst >= STAMPEDE // 2, f"sql={n_burst} clients={STAMPEDE}")
# Baseline: каждое последовательное чтение = SQL.
since = str(int(time.time()))
lats = []
for _ in range(READS):
t0 = time.perf_counter()
read_page(token, chat["id"])
lats.append((time.perf_counter() - t0) * 1000)
n = sql_count(since, chat["id"])
check("off: every read hits SQL", n >= READS * 0.9, f"sql={n} reads={READS}")
p50, p95, p99 = pctl(lats)
print(f"RESULT mode=off reads={READS} sql={n} stampede_sql={n_burst} p50={p50} p95={p95} p99={p99}")
def phase_naive():
token, uid = register_login()
# Stale read: тёплый кэш + запись + повторное чтение.
chat = setup_chat(token, uid, 2)
read_page(token, chat["id"]) # прогрев кэша
req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "stale-probe"}, token=token)
page = read_page(token, chat["id"])
visible = any(m["text"] == "stale-probe" for m in page["items"])
check("naive: stale read OBSERVED (cache returned old page after write)", not visible,
f"visible={visible}")
print(f"RESULT mode=naive stale_observed={not visible}")
def phase_versioned():
token, uid = register_login()
# Read-after-write: запись видна сразу даже при тёплом кэше.
chat = setup_chat(token, uid, 2)
read_page(token, chat["id"])
req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "stale-probe"}, token=token)
page = read_page(token, chat["id"])
visible = any(m["text"] == "stale-probe" for m in page["items"])
check("versioned: read-after-write OK (no stale)", visible)
# Stampede ПОД защитой: single-flight схлопывает 32 холодных чтения в 1 SQL.
chat2 = setup_chat(token, uid, 5)
n_burst = concurrent_burst(token, chat2["id"])
check("versioned: single-flight -> exactly 1 SQL on cold key", n_burst == 1,
f"sql={n_burst} clients={STAMPEDE}")
# Тёплые чтения обслуживает кэш.
since = str(int(time.time()))
lats = []
for _ in range(READS):
t0 = time.perf_counter()
read_page(token, chat["id"])
lats.append((time.perf_counter() - t0) * 1000)
n = sql_count(since, chat["id"])
check("versioned: warm reads served from cache", n <= 2, f"sql={n} reads={READS}")
p50, p95, p99 = pctl(lats)
print(f"RESULT mode=versioned reads={READS} sql={n} stampede_sql={n_burst} p50={p50} p95={p95} p99={p99}")
def phase_recovery():
token, uid = register_login()
chat = setup_chat(token, uid, 3)
read_page(token, chat["id"])
sh("docker compose restart redis")
check("recovery: api ready after redis restart", wait_ready(90, 200))
st, _ = req("GET", "/api/v1/users/me", token=token)
check("recovery: session still valid (source of truth = postgres)", st == 200, str(st))
since = str(int(time.time()))
page = read_page(token, chat["id"])
check("recovery: history readable after cache loss", len(page["items"]) == 3)
req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "after-restart"}, token=token)
page = read_page(token, chat["id"])
check("recovery: read-after-write OK with rebuilt cache",
any(m["text"] == "after-restart" for m in page["items"]))
n = sql_count(since, chat["id"])
check("recovery: cache rebuilds (1 sql for 2 reads)", n == 1, f"sql={n}")
print(f"RESULT mode=recovery sql_after_restart={n}")
def main():
global BASE
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default=BASE)
ap.add_argument("--phase", required=True, choices=["off", "naive", "versioned", "recovery"])
a = ap.parse_args()
BASE = a.base_url
{"off": phase_off, "naive": phase_naive,
"versioned": phase_versioned, "recovery": phase_recovery}[a.phase]()
if FAILURES:
print(f"PHASE {a.phase} FAILED: {FAILURES}")
raise SystemExit(1)
print(f"PHASE {a.phase} DONE")
if __name__ == "__main__":
main()
+50
View File
@@ -0,0 +1,50 @@
#!/usr/bin/env python3
"""Сравнение двух label'ов: python student-tests/compare.py --before before --after after"""
import argparse
import csv
def load(path):
d = {}
with open(path, newline="", encoding="utf-8") as f:
for r in csv.DictReader(f):
d[(r["phase"], r["history"], r["clients"])] = r
return d
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--before", required=True)
ap.add_argument("--after", required=True)
ap.add_argument("--results", default="student-tests/results")
ap.add_argument("--out", default="student-tests/results/summary.md")
args = ap.parse_args()
b = load(f"{args.results}/{args.before}.csv")
a = load(f"{args.results}/{args.after}.csv")
lines = [f"# Трек 1: сравнение `{args.before}` → `{args.after}`", ""]
for phase in ("read", "write"):
keys = sorted(k for k in b if k[0] == phase and k in a)
if not keys:
continue
lines.append(f"## Фаза `{phase}`")
lines.append("")
lines.append("| H | C | rps до | rps после | Δ rps | p95 до | p95 после | p99 до | p99 после | RSS max до | RSS max после |")
lines.append("|---|---|---|---|---|---|---|---|---|---|---|")
for k in keys:
rb, ra = b[k], a[k]
dr = (float(ra["rps"]) - float(rb["rps"])) / float(rb["rps"]) * 100 if float(rb["rps"]) else 0
lines.append(f"| {k[1]} | {k[2]} | {rb['rps']} | {ra['rps']} | {dr:+.0f}% | "
f"{rb['p95_ms']} | {ra['p95_ms']} | {rb['p99_ms']} | {ra['p99_ms']} | "
f"{rb['rss_max_mib']} | {ra['rss_max_mib']} |")
lines.append("")
with open(args.out, "w", encoding="utf-8") as f:
f.write("\n".join(lines) + "\n")
print("\n".join(lines))
print(f"\nsaved {args.out}")
if __name__ == "__main__":
main()
+117
View File
@@ -0,0 +1,117 @@
#!/usr/bin/env python3
"""Проверка expiry при коротком SESSION_TTL_SECONDS (стенд поднят скриптом).
Устойчивость к медленному старту после перезапуска api:
- заголовки ищем в lower-case (Go шлёт "Www-Authenticate", а не "WWW-Authenticate");
- логин повторяется, пока на сессии не останется достаточный запас времени,
иначе «свежий» запрос ловил 401 из-за гонки времени при очень коротком TTL.
"""
import argparse
import base64
import json
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
BASE = "http://localhost:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
FAILURES = []
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 _lower_headers(headers):
"""Ключи заголовков в нижнем регистре: регистр присылки не важен."""
return {k.lower(): v for k, v in headers.items()}
def www_auth(hdr):
return hdr.get("www-authenticate", "")
def req(method, path, body=None, token=None, basic=None):
headers, data = {}, None
if body is not None:
data = json.dumps(body).encode()
headers["Content-Type"] = "application/json"
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode()
r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(r, timeout=10) as resp:
p = resp.read().decode()
return resp.status, _lower_headers(resp.headers), (json.loads(p) if p else None)
except urllib.error.HTTPError as e:
p = e.read().decode()
try:
return e.code, _lower_headers(e.headers), json.loads(p)
except ValueError:
return e.code, _lower_headers(e.headers), None
def seconds_left(sess):
"""Сколько секунд осталось до истечения — по expires_at из ответа сервера."""
exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00"))
return (exp - datetime.now(timezone.utc)).total_seconds()
def login_fresh(uname, min_left=1.5, attempts=5):
"""Логин с повторами, пока на сессии не останется >= min_left секунд.
Защита от медленных первых запросов сразу после перезапуска контейнера."""
sess = None
for i in range(attempts):
st, _, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}")
assert st == 201, f"login failed: {st} {sess}"
if seconds_left(sess) >= min_left:
return sess
time.sleep(0.3)
return sess # последний вариант, даже если запас мал
def main():
global BASE
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default=BASE)
BASE = ap.parse_args().base_url
uname = "exp" + uuid.uuid4().hex[:10]
st, _, body = req("POST", "/api/v1/users",
{"username": uname, "display_name": "EX", "password": PASSWORD})
assert st == 201, f"register failed: {st} {body}"
sess = login_fresh(uname)
check("login 201 with short TTL", True)
token = sess["token"]
# Свежий токен обязан работать сразу после логина.
st, _, _ = req("GET", "/api/v1/users/me", token=token)
check("fresh token 200", st == 200, str(st))
# Ждём гарантированного истечения: реальный остаток + 1 с запаса.
wait = seconds_left(sess) + 1.0
time.sleep(max(wait, 0.5))
st, hdr, _ = req("GET", "/api/v1/users/me", token=token)
check("expired token -> 401", st == 401, str(st))
check("expired WWW-Authenticate Bearer", www_auth(hdr).startswith("Bearer"),
f"got {www_auth(hdr)!r}")
st, _, _ = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}")
check("re-login after expiry 201", st == 201)
if FAILURES:
print(f"FAILED {len(FAILURES)}: {FAILURES}")
raise SystemExit(1)
print("EXPIRY CHECKS PASSED")
if __name__ == "__main__":
main()
+10
View File
@@ -0,0 +1,10 @@
-- План запроса keyset-пагинации истории: первая страница (курсор = начало времён).
-- Ожидаем WITH index: Limit -> Index Scan using messages_history_idx
-- Ожидаем WITHOUT index: Limit -> Sort -> Seq Scan on messages
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'chat'
AND (created_at, id) > ('2020-01-01T00:00:00+00', '00000000-0000-0000-0000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+143
View File
@@ -0,0 +1,143 @@
#!/usr/bin/env python3
"""Уровень 4: деградация при потере сервисов.
Redis down -> API обслуживает запросы через SQL (200), логи warn.
Postgres down -> /health/ready 503 и защищённые запросы 503 (не 200, не «аноним доверен»).
Запуск из корня репозитория:
python student-tests/failover_tests.py --base-url http://localhost:8080
"""
import argparse
import base64
import json
import subprocess
import time
import urllib.error
import urllib.request
import uuid
FAILURES = []
BASE = "http://localhost:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
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 sh(cmd):
subprocess.run(cmd, shell=True, check=True, capture_output=True)
def req(method, path, body=None, token=None, basic=None):
headers, data = {}, None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode()
r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(r, timeout=10) as resp:
payload = resp.read().decode()
return resp.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read().decode()
try:
return e.code, json.loads(payload)
except ValueError:
return e.code, None
def wait_ready(timeout=60, want=200):
deadline = time.time() + timeout
while time.time() < deadline:
st, _ = req("GET", "/health/ready")
if st == want:
return True
time.sleep(1)
return False
def main():
global BASE
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default=BASE)
BASE = ap.parse_args().base_url
# Создаём пользователя
uname = "fo" + uuid.uuid4().hex[:10] # без дефиса
st, body = req("POST", "/api/v1/users", {"username": uname, "display_name": "FO", "password": PASSWORD})
print(f"DEBUG register: {st} {body}")
assert st == 201, f"register failed: {st} {body}"
st, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}")
print(f"DEBUG login: {st} {sess}")
assert st == 201, f"login failed: {st} {sess}"
token = sess["token"]
# Узнаём свой id через /me
me_st, me = req("GET", "/api/v1/users/me", token=token)
print(f"DEBUG /me: {me_st} {me}")
assert me_st == 200, f"/me failed: {me_st} {me}"
# Создаём чат с самим собой
st, chat = req("POST", "/api/v1/chats", {"title": "failover", "member_ids": [me["id"]]}, token=token)
print(f"DEBUG create chat: {st} {chat}")
assert st == 201, f"create chat failed: {st} {chat}"
# ── Redis down: деградация в SQL, не отказ ──
sh("docker compose stop redis")
time.sleep(2)
st, _ = req("GET", "/health/ready")
check("redis down: ready stays 200 (cache optional)", st == 200, str(st))
st, _ = req("GET", "/api/v1/users/me", token=token)
check("redis down: auth via postgres 200", st == 200, str(st))
st, _ = req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "during redis outage"}, token=token)
check("redis down: write 201", st == 201, str(st))
st, _ = req("GET", f"/api/v1/chats/{chat['id']}/messages?limit=10", token=token)
check("redis down: read 200", st == 200, str(st))
sh("docker compose start redis")
check("redis back: ready 200", wait_ready(60, 200))
# ── Postgres down: ограниченные ошибки, аноним не доверен ──
sh("docker compose stop postgres")
check("postgres down: ready becomes 503", wait_ready(60, 503))
st, _ = req("GET", "/api/v1/users/me", token=token)
check("postgres down: protected request 503 (not 200/401)", st == 503, str(st))
st, _ = req("GET", "/api/v1/users/me")
check("postgres down: anonymous still 401", st == 401, str(st))
sh("docker compose start postgres")
check("postgres back: ready 200", wait_ready(90, 200))
st, _ = req("GET", "/api/v1/users/me", token=token)
check("postgres back: same session valid 200", st == 200, str(st))
# ── Logout при сбое Redis: никаких «тихих» 204, оставляющих токен живым ──
st, sess2 = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}")
assert st == 201, f"second login failed: {st} {sess2}"
token2 = sess2["token"]
sh("docker compose stop redis")
time.sleep(2)
st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2)
check("redis down: logout returns 503, not silent 204", st == 503, str(st))
st, _ = req("GET", "/api/v1/users/me", token=token2)
check("redis down: token already revoked in postgres -> 401", st == 401, str(st))
sh("docker compose start redis")
check("redis back (2): ready 200", wait_ready(60, 200))
st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2)
check("redis back: logout retry 204 (DEL confirmed)", st == 204, str(st))
st, _ = req("GET", "/api/v1/users/me", token=token2)
check("after retry logout: token still 401", st == 401, str(st))
if FAILURES:
print(f"FAILED {len(FAILURES)}: {FAILURES}")
raise SystemExit(1)
print("ALL FAILOVER TESTS PASSED")
if __name__ == "__main__":
main()
+265
View File
@@ -0,0 +1,265 @@
#!/usr/bin/env python3
"""Студенческие тесты lab2 (Bearer-аутентификация). Одна команда:
python student-tests/run_tests.py --base-url http://localhost:8080
"""
import argparse
import base64
import json
import threading
import urllib.error
import urllib.request
import uuid
FAILURES = []
BASE = "http://localhost:8080"
PASSWORD = "Example-only-not-a-real-secret-123" # 38 code points: в диапазоне 12..128
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 _lower_headers(headers):
"""Ключи заголовков в нижнем регистре.
Go шлёт WWW-Authenticate как "Www-Authenticate" (каноническая MIME-форма),
а dict(headers) сохраняет регистр как пришёл. Чтобы тест не зависел от
регистра, всегда ищем заголовки в lower-case."""
return {k.lower(): v for k, v in headers.items()}
def www_auth(hdr):
"""Значение WWW-Authenticate независимо от регистра ключа."""
return hdr.get("www-authenticate", "")
def req(method, path, body=None, raw=None, token=None, basic=None,
ctype="application/json", extra_headers=None):
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:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + base64.b64encode(basic.encode("utf-8")).decode("ascii")
if extra_headers:
headers.update(extra_headers)
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, _lower_headers(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, _lower_headers(e.headers), json.loads(payload)
except ValueError:
return e.code, _lower_headers(e.headers), None
def register(username=None, password=PASSWORD, display="Тест Юникод ✓"):
username = username or "u" + uuid.uuid4().hex[:12]
return req("POST", "/api/v1/users",
{"username": username, "display_name": display, "password": password})
def login(username, password=PASSWORD):
return req("POST", "/api/v1/auth/sessions", basic=f"{username}:{password}")
def main():
global BASE
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default=BASE)
BASE = ap.parse_args().base_url
# ── health и номерки ──
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")))
st, _, body = req("GET", "/health/ready")
check("health ready 200", st == 200 and body == {"status": "ok"})
# ── валидация регистрации ──
st, _, _ = req("POST", "/api/v1/users", raw='{"username": "abc",')
check("malformed JSON -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users",
{"username": "extrafield1", "display_name": "x", "password": PASSWORD, "junk": 1})
check("extra field -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users", {"username": "BadName", "display_name": "x", "password": PASSWORD})
check("username pattern -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users", {"username": "wsname1", "display_name": " ", "password": PASSWORD})
check("whitespace display_name -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users", {"username": "shortpw1", "display_name": "x", "password": "short"})
check("password < 12 -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users", {"username": "longpw1", "display_name": "x", "password": "x" * 129})
check("password > 128 -> 400", st == 400)
st, _, _ = req("POST", "/api/v1/users", {"username": "wspw1", "display_name": "x", "password": " "})
check("whitespace password -> 400", st == 400)
st, _, alice = register()
check("register 201", st == 201)
check("no password/hash in User response",
isinstance(alice, dict) and "password" not in alice and "password_hash" not in alice)
st2, _, _ = register(username=alice["username"])
check("duplicate username -> 409", st2 == 409)
# ── вход: неверные/неизвестные/успех ──
st, hdr, _ = login(alice["username"], "Wrong-" + PASSWORD)
check("wrong password -> 401", st == 401)
check("wrong password WWW-Authenticate Basic", www_auth(hdr).startswith("Basic"),
f"got {www_auth(hdr)!r}")
st, hdr, _ = login("nosuchuser" + uuid.uuid4().hex[:6])
check("unknown user -> 401 same shape",
st == 401 and www_auth(hdr).startswith("Basic"), f"got {www_auth(hdr)!r}")
st, _, sess = login(alice["username"])
check("login 201 session", st == 201 and sess["token_type"] == "Bearer" and len(sess["token"]) >= 32)
check("session has expires_at and user", "expires_at" in sess and "user" in sess)
token_a = sess["token"]
_, _, bob = register(); _, _, sess_b = login(bob["username"]); token_b = sess_b["token"]
_, _, carol = register(); _, _, sess_c = login(carol["username"]); token_c = sess_c["token"]
# ── правила аутентификации lab2 ──
st, hdr, _ = req("GET", "/api/v1/users/me")
check("no auth -> 401 + Bearer header",
st == 401 and www_auth(hdr).startswith("Bearer"), f"got {www_auth(hdr)!r}")
st, _, _ = req("GET", "/api/v1/users/me", extra_headers={"X-User-Id": alice["id"]})
check("X-User-Id ignored -> 401", st == 401)
st, hdr, _ = req("GET", "/api/v1/users/me", basic=f"{alice['username']}:{PASSWORD}")
check("Basic on business endpoint -> 401 Bearer",
st == 401 and www_auth(hdr).startswith("Bearer"), f"got {www_auth(hdr)!r}")
st, _, _ = req("GET", "/api/v1/users/me", token="not-a-valid-token")
check("garbage Bearer -> 401", st == 401)
st, _, me = req("GET", "/api/v1/users/me", token=token_a)
check("me with Bearer 200", st == 200 and me["id"] == alice["id"])
# ── чаты и доступ ──
st, _, chat = req("POST", "/api/v1/chats",
{"title": "Проект по ВНП", "member_ids": [alice["id"], bob["id"]]}, token=token_a)
check("create chat 201", st == 201)
cid = chat["id"]
st, _, _ = req("GET", f"/api/v1/chats/{cid}", token=token_c)
check("outsider GET chat -> 404", st == 404)
st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": "hi"}, token=token_c)
check("outsider POST message -> 404", st == 404)
st, _, body = req("GET", "/api/v1/chats", token=token_c)
check("outsider list hides foreign chat", st == 200 and all(c["id"] != cid for c in body["items"]))
# ── валидация сообщений ──
st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": ""}, token=token_a)
check("empty text -> 400", st == 400)
st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": " \n "}, token=token_a)
check("whitespace text -> 400", st == 400)
st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": "x" * 4001}, token=token_a)
check("text > 4000 -> 400", st == 400)
text = "Привет, Боб! 🚀 Ünïcödé ✓"
st, _, msg = req("POST", f"/api/v1/chats/{cid}/messages", {"text": text}, token=token_a)
check("unicode round-trip exact", st == 201 and msg["text"] == text)
# ── пагинация ──
for i in range(24):
req("POST", f"/api/v1/chats/{cid}/messages", {"text": f"msg-{i:02d}"}, token=token_b)
hist, cursor, pages = [], None, 0
while True:
q = f"/api/v1/chats/{cid}/messages?limit=10" + (f"&cursor={cursor}" if cursor else "")
st, _, page = req("GET", q, token=token_b)
pages += 1
hist.extend(page["items"])
cursor = page["next_cursor"]
if not cursor:
break
ids = [m["id"] for m in hist]
check("25 msgs -> 3 pages, no repeats", pages == 3 and len(ids) == 25 and len(set(ids)) == 25)
pairs = [(m["created_at"], m["id"]) for m in hist]
bad = [i for i in range(len(pairs) - 1) if pairs[i] > pairs[i + 1]]
check("history ordered by (created_at, id)", not bad, f"{len(bad)} inversions")
st, _, chat2 = req("POST", "/api/v1/chats",
{"title": "other", "member_ids": [alice["id"], bob["id"]]}, token=token_a)
req("POST", f"/api/v1/chats/{chat2['id']}/messages", {"text": "o1"}, token=token_a)
req("POST", f"/api/v1/chats/{chat2['id']}/messages", {"text": "o2"}, token=token_a)
_, _, p2 = req("GET", f"/api/v1/chats/{chat2['id']}/messages?limit=1", token=token_a)
st, _, _ = req("GET", f"/api/v1/chats/{cid}/messages?limit=10&cursor={p2['next_cursor']}", token=token_a)
check("cursor from another chat -> 400", st == 400)
ok = True
for v in ("0", "101", "abc"):
st, _, _ = req("GET", f"/api/v1/chats/{cid}/messages?limit={v}", token=token_a)
ok = ok and st == 400
check("limit 0/101/abc -> 400", ok)
# ── logout и отзыв ──
_, _, sess_b2 = login(bob["username"])
token_b2 = sess_b2["token"]
st, _, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token_b2)
check("logout -> 204", st == 204)
st, _, _ = req("GET", "/api/v1/users/me", token=token_b2)
check("revoked token -> 401", st == 401)
st, _, _ = req("GET", "/api/v1/users/me", token=token_b)
check("other session of same user still valid", st == 200)
# ── гонка регистрации: UNIQUE-ограничение (имя БЕЗ дефиса: маска username) ──
race_name = "race" + uuid.uuid4().hex[:10]
results, lock = [], threading.Lock()
def racer():
s, _, _ = register(username=race_name)
with lock:
results.append(s)
ts = [threading.Thread(target=racer) for _ in range(10)]
for t in ts: t.start()
for t in ts: t.join()
check("race registration: one 201, rest 409",
results.count(201) == 1 and results.count(409) == 9, str(results))
# ── rollback составной операции ──
_, _, before = req("GET", "/api/v1/chats", token=token_a)
n_before = len(before["items"])
st, _, _ = req("POST", "/api/v1/chats",
{"title": "rollback-probe", "member_ids": [alice["id"], str(uuid.uuid4())]}, token=token_a)
check("chat with unknown member -> 400", st == 400)
_, _, after = req("GET", "/api/v1/chats", token=token_a)
check("rollback: no partial chat",
len(after["items"]) == n_before and all(c["title"] != "rollback-probe" for c in after["items"]))
# ── конкурентные записи ──
errs = []
def writer(idx):
for j in range(10):
s, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": f"c{idx}-{j}"}, token=token_b)
if s != 201:
errs.append((idx, j, s))
ts = [threading.Thread(target=writer, args=(i,)) for i in range(10)]
for t in ts: t.start()
for t in ts: t.join()
check("100 concurrent sends all 201", not errs, str(errs[:5]))
items, cur = [], None
while True:
q = f"/api/v1/chats/{cid}/messages?limit=100" + (f"&cursor={cur}" if cur else "")
st, _, page = req("GET", q, token=token_b)
items.extend(page["items"])
cur = page["next_cursor"]
if not cur:
break
expected = {f"c{i}-{j}" for i in range(10) for j in range(10)}
got = {m["text"] for m in items}
check("exactly 100 unique concurrent messages", expected <= got and len(got & expected) == 100)
# ── прочее контрактное ──
st, _, _ = req("POST", "/api/v1/users",
raw='{"username":"cttest1","display_name":"x","password":"' + PASSWORD + '"}',
ctype="text/plain")
check("wrong Content-Type -> 415", st == 415)
st, _, body = req("GET", "/nope")
check("unknown route -> 404 envelope", st == 404 and body and body["error"]["code"] == "not_found")
if FAILURES:
print(f"FAILED {len(FAILURES)}: {FAILURES}")
raise SystemExit(1)
print("ALL STUDENT TESTS PASSED")
if __name__ == "__main__":
main()