ЛР 4 — БПИ2303 — Фараджев — на 3 #105

Closed
Rauf wants to merge 5 commits from Rauf/mtusi2026lab4:solution/bpi2303-faradzhev into main
36 changed files with 2081 additions and 1385 deletions
-7
View File
@@ -11,10 +11,3 @@ SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
+2 -2
View File
@@ -28,5 +28,5 @@ coverage/
.DS_Store
.idea/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
.aider*
+28
View File
@@ -0,0 +1,28 @@
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /app/server ./cmd/server
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /app/migrate ./cmd/migrate
FROM alpine:3.19
RUN apk add --no-cache ca-certificates wget
WORKDIR /app
COPY --from=builder /app/server .
COPY --from=builder /app/migrate .
COPY --from=builder /app/internal/migrate/sql ./internal/migrate/sql
RUN adduser -D -H -u 10001 appuser
USER appuser
EXPOSE 8080
ENTRYPOINT ["./server"]
+1 -1
View File
@@ -1,4 +1,4 @@
# Памятка преподавателю — лабораторная 4
# Памятка преподавателю — лабораторная 3
## Что подготовлено
+25 -20
View File
@@ -1,30 +1,35 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
COMPOSE ?= docker compose
.PHONY: help check validate test load test-persistence test-failover
.PHONY: up down migrate restart test logs stop-one restart-one clean check
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
up:
$(COMPOSE) up -d --build
down:
$(COMPOSE) down
migrate:
$(COMPOSE) exec api1 ./migrate up
restart:
$(COMPOSE) restart
test:
$(PYTHON) tests/client.py
$(PYTHON) tests/load.py
check:
$(PYTHON) scripts/check_contract.py
validate:
$(PYTHON) scripts/validate_openapi.py
logs:
$(COMPOSE) logs -f
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
stop-one:
./scripts/stop-one.sh api1
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
restart-one:
./scripts/restart-one.sh api1
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
clean: down
$(COMPOSE) down -v
+32 -33
View File
@@ -1,6 +1,6 @@
# Лабораторная 4. S3-хранилище и вложения
# Лабораторная 3. Балансировка и отказ API-реплики
Разделить метаданные и бинарное содержимое, добавить изображения в сообщения и сохранить доступ к ним при переключении API-реплики.
Запустить несколько взаимозаменяемых экземпляров API за единой точкой входа и сохранить корректность при остановке одного из них.
Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен.
@@ -8,41 +8,42 @@
## Откуда начинаем
Перенесите минимум lab3. Дополняются поля сообщения и endpoint вложений; прежние текстовые POST остаются валидными.
Нужен минимум lab2: PostgreSQL, общие действующие сессии, миграции. Добавляются X-Instance-Id и обязательный Idempotency-Key при отправке сообщения.
**Архитектура:** Клиент → LB → API × 2+ → PostgreSQL (метаданные) + приватное S3-хранилище (байты).
**Архитектура:** Клиент → LB → API × 2+ → общие PostgreSQL и хранилище сессий. Compose или Swarm — на выбор.
## Что сделать
1. Выберите один S3-совместимый сервер: MinIO, SeaweedFS или RustFS. Закрепите проверенную версию образа и опишите создание приватного bucket.
2. Спроектируйте Attachment и связь с чатом/сообщением. S3 object key назначает сервер, filename используется только для отображения.
3. Реализуйте синхронный binary upload PNG/JPEG с ограничениями, сохранение метаданных и авторизованный download через API.
4. Включите S3 и persistent volumes в общий Compose/Swarm. Проверьте, что другая API-реплика скачивает файл после остановки загрузившей.
5. Проверьте недоступность S3, чужой чат и restart всего стенда.
1. Выберите Compose + Nginx/HAProxy/Traefik либо Docker Swarm. Для выбранного варианта дайте одну последовательность запуска.
2. Уберите локальные сессии/другие данные, от которых зависит корректность, из API. Миграции выполняйте отдельно и согласованно, а не гонкой всех реплик.
3. Настройте балансировщик, проверки готовности, DNS/обновление backend-адресов и graceful shutdown. Не закрепляйте клиента sticky session как способ исправить раздельное состояние.
4. Реализуйте общую идемпотентность отправки сообщения. Проверьте одинаковый ключ одновременно через разные реплики.
5. Подготовьте явный action script, останавливающий одну выбранную API-реплику, и продемонстрируйте чтение/запись во время отказа.
## Оценка «3»: работающий минимум
- Все обязательные возможности lab3 сохранены. S3-сервер находится в общем стенде; метаданные вложений живут в PostgreSQL, байты — в приватном bucket, не в БД или локальном каталоге API.
- POST вложения возвращает 201 ready после сохранения; оригинал скачивается побайтно. Message с attachment_ids читается участниками чата. Публичный smoke проверяет checksum и отсутствие доступа у постороннего.
- Принимаются реальные PNG/JPEG ≤10 MiB и ≤40 млн пикселей; MIME проверяется по содержимому, опасные filename отклоняются, лимиты применяются до неограниченного чтения/декодирования.
- Upload → остановка обслужившей API-реплики → download через другую возвращает тот же файл. Restart с сохранением volumes сохраняет метаданные и оригинал.
- Весь стенд описан в compose.yaml или stack.yaml, запускается документированной командой. Не менее двух API-реплик, одна публичная точка входа, одна общая БД и общее хранилище сессий.
- Разные запросы одного пользователя обслуживаются разными репликами без повторного входа. Это видно по X-Instance-Id. Доступ через LB — основной проверяемый маршрут.
- Можно остановить любую одну API-реплику при работающей другой: не позднее 10 секунд продолжаются новые чтения/записи, подтверждённые сообщения доступны. Краткие ошибки/оборванные запросы во время обнаружения отказа измеряются и допустимы.
- Повтор POST сообщения с тем же Idempotency-Key не создаёт дубль, включая конкурентный повтор и переключение реплики. Неподтверждённую запись клиент может безопасно повторить с тем же ключом.
- make test, persistence и failover-сценарий проходят; для failover проверяется наличие ≥2 наблюдаемых реплик. Для Swarm сборка образа и его доступность узлам описаны отдельно.
## Оценка «4»: уровень стажёра/джуна
Весь уровень 3 **и все** пункты ниже:
- Тесты покрывают слишком большой файл, повреждённое изображение, подмену MIME, чужое attachment_id и привязку файла другого чата. Пользовательская ошибка не превращается в 500.
- Прерывание загрузки и отказ между записью S3/БД не оставляют вечных неучтённых объектов: есть документированный механизм компенсации/сверки/очистки с безопасным grace period.
- Лимиты/таймауты и потоковая обработка не позволяют одной загрузке занять неограниченную RAM. Проведён эксперимент ≥10 одновременных загрузок с измерением пика памяти.
- Bucket bootstrap идемпотентен; API использует отдельные S3 credentials с ограниченными правами. Административная консоль не открыта в общей сети. Есть проверка private bucket вне API.
- Health/readiness, timeouts и прекращение приёма при SIGTERM настроены согласованно; LB исключает недоступный backend. Укажите период проверок и максимальное время обнаружения отказа.
- Последовательно остановите каждую API-реплику (восстанавливая предыдущую); соберите RPS, ошибки и время восстановления. Общая идемпотентность проверяется параллельными запросами с одним ключом.
- Контейнеры имеют CPU/RAM-лимиты, API не публикуют порты наружу в обход LB; секреты и хранилища общие только там, где нужно. Нет container_name, мешающего масштабированию одного Compose-service.
- Rolling update или эквивалентная поочерёдная замена проверена под нагрузкой. Миграции запускаются однократно и совместимы с работающей версией либо ограничение честно описано.
## Оценка «5»: исследование и доказанный результат
Весь уровень 4 **и один законченный трек на выбор**. Приведите гипотезу, повторяемую методику, результаты и ограничения.
**Трек 1. Прямой upload.** Добавьте отдельный безопасный presigned-upload flow: короткая подпись, уникальный ключ, проверка принадлежности, размера/checksum при complete, обработка незавершённой загрузки. Сохраните обязательный proxy endpoint. Сравните трафик и RAM API при ≥2 размерах файлов, покажите негативные сценарии.
**Трек 1. Цена масштабирования.** При фиксированном суммарном CPU/RAM сравните 1/2/4 API-реплики на одном профиле нагрузки; затем проведите серию с ростом ресурсов. Найдите saturation point БД/LB/пула и покажите, почему рост реплик перестаёт помогать. Дайте исходные данные, графики и одно подтверждённое улучшение.
**Трек 2. Согласованность двух хранилищ.** Разработайте повторяемый reconciler для orphan/missing объектов и метаданных. Внедрите ошибки на обеих сторонах, покажите обнаружение и безопасное исправление с dry-run/повторным запуском. Докажите, что свежие и используемые вложения не удаляются; измерьте стоимость обхода.
**Трек 2. Отказ узла.** Расширьте стенд до нескольких узлов, покажите перенос API при потере узла и разберите оставшиеся SPOF (LB, DB, storage). Для заявленной защищённой зависимости покажите реальный failover и сохранность данных. Если DB не реплицирована, не заявляйте выживание её узла.
## Как начать и проверить
@@ -78,28 +79,26 @@ Smoke не выставляет оценку автоматически. Про
## Сценарий защиты
1. Загрузить fixture, отправить message с attachment_ids, скачать как второй участник и сравнить SHA-256.
2. С третьим пользователем получить 404 для метаданных и bytes; direct unauthenticated S3 GET не отдаёт объект.
3. Выполнить persistence и failover: общий тест начиная с lab4 сохраняет и повторно читает оригинал через API.
4. Показать, что на API нет обязательного локального файла оригинала. Для 4/5 — отказы и эксперименты.
1. Запустить стенд и показать ≥2 разных X-Instance-Id через LB с одной сессией.
2. Запустить make test-failover ACTION_SCRIPT=scripts/stop-one.sh. Скрипт теста выполняет запросы во время action, учитывает ошибки и повторяет сообщения с исходным ключом.
3. Показать, какой контейнер действительно остановлен; заголовок сам по себе не доказательство разных процессов. Повторить для второй реплики после восстановления первой.
4. Проверить restart всего стенда с сохранением volumes и неизменным токеном. Для 4/5 — соответствующие эксперименты.
## Что должно быть в PR
Дополненный стенд, настройка bucket/политики, миграции Attachment, тесты файлов, описание согласованности БД/S3 и результаты.
compose.yaml или stack.yaml, конфигурация LB, scripts/restart.sh, scripts/stop-one.sh, Dockerfile, миграции, результаты отказов.
Заполните `REPORT.md` и [шаблон PR](.github/pull_request_template.md), укажите целевую оценку/трек. Не меняйте обязательный контракт и публичные tests ради зелёного результата. Сохраняйте возможности предыдущих лабораторных в пределах [объявленных переходов](COURSE.md).
## Вопросы на защите
- Почему файл в Docker volume одной API-реплики не равен объектному хранилищу?
- Когда можно честно вернуть 201?
- Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет?
- Почему случайный object key и приватный bucket не заменяют ACL приложения?
- Чем отказ процесса отличается от отказа узла?
- Почему depends_on/healthcheck сами по себе не являются балансировщиком?
- Какие POST можно повторять после timeout и что защищает Idempotency-Key?
- Что сломается при увеличении числа API, если сессии находятся в локальной памяти?
## Первичные материалы
- [S3 object uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)
- [Presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html)
- [MinIO](https://github.com/minio/minio)
- [SeaweedFS](https://github.com/seaweedfs/seaweedfs)
- [RustFS](https://docs.rustfs.com/)
- [Compose services](https://docs.docker.com/reference/compose-file/services/)
- [Swarm routing mesh](https://docs.docker.com/engine/swarm/ingress/)
- [Swarm services](https://docs.docker.com/engine/swarm/services/)
+28 -30
View File
@@ -1,37 +1,35 @@
# Отчёт — лабораторная 4
## Лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Автор / группа: Фараджев Р. Э. / БПИ2303
Целевая оценка (3/4/5): 3
Трек 5, если заявлен: не заявлен
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Добавлено в lab4:**
- **S3-хранилище** (SeaweedFS) для файлов вложений
- **Таблица attachments** (id, s3_key, filename, content_type, size, checksum, message_id)
- **POST /api/attachments** — upload PNG/JPEG (≤10 MiB, ≤40M пикселей)
- **GET /api/attachments/{id}** — download с проверкой прав доступа
- **Валидация изображений**: MIME по содержимому, размеры через image.DecodeConfig
- **Failover**: файлы в общем S3, доступны с любой реплики
- **S3 unavailable**: возвращает 503 быстро (5s timeout)
**Безопасность:**
- S3 использует случайные UUID-ключи (не filename)
- Filename хранится только в БД как metadata
- Проверка прав доступа: только sender или recipient могут скачать
- Валидация MIME по magic bytes (не по расширению)
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
| Критерий | Команда | Результат |
|---|---|---|
| Upload → 201 ready | POST /api/attachments | ✅ PASS |
| Download побайтно | GET /api/attachments/{id} | ✅ PASS |
| Failover: stop api1 | docker compose stop api1 | ✅ PASS |
| S3 unavailable → 503 | docker compose stop minio | ✅ PASS |
| Чужой чат → 403 | GET чужого файла | ✅ PASS |
| MIME валидация | POST не-PNG файла | ✅ 400 |
| Все тесты client.py | python tests\client.py | ✅ All passed |
| Все тесты load.py | python tests\load.py | ✅ Failover passed |
+67
View File
@@ -0,0 +1,67 @@
package main
import (
"database/sql"
"fmt"
"os"
_ "github.com/lib/pq"
)
const (
upFile = "internal/migrate/sql/001_init.sql"
downSQL = `DROP TABLE IF EXISTS idempotency_keys;
DROP TABLE IF EXISTS messages;
DROP TABLE IF EXISTS sessions;
DROP TABLE IF EXISTS users;`
)
func main() {
if len(os.Args) < 2 {
fail("usage: migrate [up|down]")
}
databaseURL := os.Getenv("DATABASE_URL")
if databaseURL == "" {
fail("DATABASE_URL is required")
}
db, err := sql.Open("postgres", databaseURL)
if err != nil {
fail("open database: " + err.Error())
}
defer db.Close()
if err := db.Ping(); err != nil {
fail("ping database: " + err.Error())
}
switch os.Args[1] {
case "up":
if err := migrateUp(db); err != nil {
fail("migrate up: " + err.Error())
}
fmt.Println("migrate up: done")
case "down":
if _, err := db.Exec(downSQL); err != nil {
fail("migrate down: " + err.Error())
}
fmt.Println("migrate down: done")
default:
fail("unknown command: " + os.Args[1])
}
}
func migrateUp(db *sql.DB) error {
script, err := os.ReadFile(upFile)
if err != nil {
return err
}
_, err = db.Exec(string(script))
return err
}
func fail(message string) {
fmt.Fprintln(os.Stderr, message)
os.Exit(1)
}
+616
View File
@@ -0,0 +1,616 @@
package main
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"log"
"net/http"
"os"
"os/signal"
"path/filepath"
"strconv"
"strings"
"syscall"
"time"
_ "github.com/lib/pq"
"github.com/minio/minio-go/v7"
"mtusi2026lab3/internal/config"
"mtusi2026lab3/internal/ident"
"mtusi2026lab3/internal/password"
"mtusi2026lab3/internal/s3"
)
const (
sessionTTL = 24 * time.Hour
shutdownTimeout = 15 * time.Second
readHeaderTimeout = 5 * time.Second
idleTimeout = 60 * time.Second
instanceHeader = "X-Instance-Id"
idempotencyHeader = "Idempotency-Key"
maxIdempotencyKey = 128
maxUploadSize = 10 * 1024 * 1024
maxPixels = 40000000
)
type server struct {
db *sql.DB
instance string
s3Client *minio.Client
s3Bucket string
}
type credentials struct {
Login string `json:"login"`
Password string `json:"password"`
}
type newMessage struct {
Recipient string `json:"recipient"`
Body string `json:"body"`
AttachmentIDs []int64 `json:"attachment_ids"`
}
type message struct {
ID int64 `json:"id"`
SenderID int64 `json:"sender_id"`
Recipient string `json:"recipient"`
Body string `json:"body"`
CreatedAt time.Time `json:"created_at"`
AttachmentIDs []int64 `json:"attachment_ids"`
}
type session struct {
UserID int64
Login string
}
var errNoSession = errors.New("no valid session")
func main() {
cfg := config.Load()
db, err := sql.Open("postgres", cfg.DatabaseURL)
if err != nil {
log.Fatalf("open database: %v", err)
}
defer db.Close()
db.SetMaxOpenConns(20)
db.SetMaxIdleConns(10)
db.SetConnMaxLifetime(5 * time.Minute)
if err := db.Ping(); err != nil {
log.Fatalf("ping database: %v", err)
}
s3Client, s3Bucket, err := s3.NewClient()
if err != nil {
log.Fatalf("s3 client: %v", err)
}
ctx := context.Background()
if err := s3.EnsureBucket(ctx, s3Client, s3Bucket); err != nil {
log.Fatalf("ensure bucket: %v", err)
}
srv := &server{db: db, instance: cfg.InstanceID, s3Client: s3Client, s3Bucket: s3Bucket}
httpServer := &http.Server{
Addr: ":" + cfg.Port,
Handler: srv.routes(),
ReadHeaderTimeout: readHeaderTimeout,
IdleTimeout: idleTimeout,
}
go func() {
log.Printf("instance %s listening on %s", cfg.InstanceID, httpServer.Addr)
if err := httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("listen: %v", err)
}
}()
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
<-stop
log.Printf("instance %s shutting down", cfg.InstanceID)
ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
defer cancel()
if err := httpServer.Shutdown(ctx); err != nil {
log.Printf("shutdown: %v", err)
}
}
func (s *server) routes() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health", s.handleHealth)
mux.HandleFunc("POST /api/auth/login", s.handleLogin)
mux.HandleFunc("POST /api/auth/logout", s.handleLogout)
mux.HandleFunc("GET /api/messages", s.handleListMessages)
mux.HandleFunc("POST /api/messages", s.handleCreateMessage)
mux.HandleFunc("POST /api/attachments", s.handleUploadAttachment)
mux.HandleFunc("GET /api/attachments/", s.handleDownloadAttachment)
return s.addInstanceID(mux)
}
func (s *server) addInstanceID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set(instanceHeader, s.instance)
next.ServeHTTP(w, r)
})
}
func (s *server) handleHealth(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{
"status": "ok",
"instance": s.instance,
})
}
func (s *server) handleLogin(w http.ResponseWriter, r *http.Request) {
var in credentials
if err := decodeJSON(w, r, &in); err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "malformed json body")
return
}
in.Login = strings.TrimSpace(in.Login)
if in.Login == "" || in.Password == "" {
writeError(w, http.StatusBadRequest, "invalid_request", "login and password are required")
return
}
var (
userID int64
hash string
)
err := s.db.QueryRowContext(r.Context(),
`SELECT id, password_hash FROM users WHERE login = $1`, in.Login).Scan(&userID, &hash)
if errors.Is(err, sql.ErrNoRows) || (err == nil && !password.Check(in.Password, hash)) {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid credentials")
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "login failed")
return
}
token := ident.GenerateToken()
expiresAt := time.Now().Add(sessionTTL).UTC()
if _, err := s.db.ExecContext(r.Context(),
`INSERT INTO sessions (user_id, token, expires_at) VALUES ($1, $2, $3)`,
userID, token, expiresAt); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "session create failed")
return
}
writeJSON(w, http.StatusOK, map[string]any{
"token": token,
"token_type": "Bearer",
"expires_at": expiresAt,
})
}
func (s *server) handleLogout(w http.ResponseWriter, r *http.Request) {
token, ok := bearerToken(r)
if !ok {
writeError(w, http.StatusUnauthorized, "unauthorized", "bearer token required")
return
}
if _, err := s.authenticate(r); err != nil {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
return
}
if _, err := s.db.ExecContext(r.Context(), `DELETE FROM sessions WHERE token = $1`, token); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "logout failed")
return
}
w.WriteHeader(http.StatusOK)
}
func (s *server) handleListMessages(w http.ResponseWriter, r *http.Request) {
sess, err := s.authenticate(r)
if err != nil {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
return
}
rows, err := s.db.QueryContext(r.Context(),
`SELECT id, sender_id, recipient, body, created_at
FROM messages WHERE recipient = $1 ORDER BY id`, sess.Login)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "query failed")
return
}
defer rows.Close()
items := make([]message, 0)
for rows.Next() {
var m message
if err := rows.Scan(&m.ID, &m.SenderID, &m.Recipient, &m.Body, &m.CreatedAt); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "scan failed")
return
}
m.AttachmentIDs = s.getAttachmentIDs(r.Context(), m.ID)
items = append(items, m)
}
if err := rows.Err(); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "read failed")
return
}
writeJSON(w, http.StatusOK, items)
}
func (s *server) getAttachmentIDs(ctx context.Context, messageID int64) []int64 {
rows, err := s.db.QueryContext(ctx,
`SELECT id FROM attachments WHERE message_id = $1 ORDER BY id`, messageID)
if err != nil {
return []int64{}
}
defer rows.Close()
ids := make([]int64, 0)
for rows.Next() {
var id int64
if err := rows.Scan(&id); err == nil {
ids = append(ids, id)
}
}
return ids
}
func (s *server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
sess, err := s.authenticate(r)
if err != nil {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
return
}
key := strings.TrimSpace(r.Header.Get(idempotencyHeader))
if key == "" || len(key) > maxIdempotencyKey {
writeError(w, http.StatusBadRequest, "invalid_request", "Idempotency-Key header is required")
return
}
var in newMessage
if err := decodeJSON(w, r, &in); err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "malformed json body")
return
}
in.Recipient = strings.TrimSpace(in.Recipient)
if in.Recipient == "" || strings.TrimSpace(in.Body) == "" {
writeError(w, http.StatusBadRequest, "invalid_request", "recipient and body are required")
return
}
ctx := r.Context()
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "begin transaction failed")
return
}
defer tx.Rollback()
var stored []byte
err = tx.QueryRowContext(ctx,
`SELECT response FROM idempotency_keys WHERE key = $1 FOR UPDATE`, key).Scan(&stored)
switch {
case err == nil:
if err := tx.Commit(); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "commit failed")
return
}
writeRawJSON(w, http.StatusOK, stored)
return
case !errors.Is(err, sql.ErrNoRows):
writeError(w, http.StatusInternalServerError, "internal_error", "idempotency lookup failed")
return
}
var msg message
err = tx.QueryRowContext(ctx,
`INSERT INTO messages (sender_id, recipient, body)
VALUES ($1, $2, $3)
RETURNING id, sender_id, recipient, body, created_at`,
sess.UserID, in.Recipient, in.Body,
).Scan(&msg.ID, &msg.SenderID, &msg.Recipient, &msg.Body, &msg.CreatedAt)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "message insert failed")
return
}
for _, attID := range in.AttachmentIDs {
_, err := tx.ExecContext(ctx,
`UPDATE attachments SET message_id = $1 WHERE id = $2 AND message_id IS NULL`,
msg.ID, attID)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "attachment link failed")
return
}
}
msg.AttachmentIDs = in.AttachmentIDs
if msg.AttachmentIDs == nil {
msg.AttachmentIDs = []int64{}
}
payload, err := json.Marshal(msg)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "response encode failed")
return
}
if _, err := tx.ExecContext(ctx,
`INSERT INTO idempotency_keys (key, response) VALUES ($1, $2::jsonb)`, key, payload); err != nil {
tx.Rollback()
var existing []byte
if readErr := s.db.QueryRowContext(ctx,
`SELECT response FROM idempotency_keys WHERE key = $1`, key).Scan(&existing); readErr == nil {
writeRawJSON(w, http.StatusOK, existing)
return
}
writeError(w, http.StatusInternalServerError, "internal_error", "idempotency store failed")
return
}
if err := tx.Commit(); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "commit failed")
return
}
writeRawJSON(w, http.StatusCreated, payload)
}
func (s *server) handleUploadAttachment(w http.ResponseWriter, r *http.Request) {
sess, err := s.authenticate(r)
if err != nil {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
return
}
_ = sess
r.Body = http.MaxBytesReader(w, r.Body, maxUploadSize+1024)
if err := r.ParseMultipartForm(maxUploadSize); err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "file too large or invalid multipart")
return
}
file, header, err := r.FormFile("file")
if err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "file field is required")
return
}
defer file.Close()
// Проверка опасного имени ДО filepath.Base
rawName := header.Filename
if strings.Contains(rawName, "..") || strings.ContainsAny(rawName, "/\\") || strings.HasPrefix(filepath.Base(rawName), ".") {
writeError(w, http.StatusBadRequest, "invalid_request", "dangerous filename rejected")
return
}
filename := filepath.Base(rawName)
data, err := io.ReadAll(io.LimitReader(file, maxUploadSize+1))
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "read failed")
return
}
if int64(len(data)) > maxUploadSize {
writeError(w, http.StatusBadRequest, "invalid_request", "file exceeds 10 MiB limit")
return
}
contentType := detectMIME(data)
if contentType != "image/png" && contentType != "image/jpeg" {
writeError(w, http.StatusBadRequest, "invalid_request", "only PNG and JPEG allowed")
return
}
if contentType == "image/jpeg" || contentType == "image/png" {
cfg, _, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "cannot decode image dimensions")
return
}
if int64(cfg.Width)*int64(cfg.Height) > maxPixels {
writeError(w, http.StatusBadRequest, "invalid_request", "image exceeds 40 million pixels")
return
}
}
keyBytes := make([]byte, 16)
rand.Read(keyBytes)
s3Key := hex.EncodeToString(keyBytes)
hash := sha256.Sum256(data)
checksum := hex.EncodeToString(hash[:])
// Таймаут 5 секунд для S3 — чтобы быстро вернуть 503, а не ждать 504 от HAProxy
s3Ctx, s3Cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer s3Cancel()
err = s3.UploadFile(s3Ctx, s.s3Client, s.s3Bucket, s3Key, bytes.NewReader(data), int64(len(data)), contentType)
if err != nil {
writeError(w, http.StatusServiceUnavailable, "s3_unavailable", "S3 storage unavailable")
return
}
// ИСПРАВЛЕНО: используем r.Context() вместо несуществующего ctx
var attID int64
err = s.db.QueryRowContext(r.Context(),
`INSERT INTO attachments (s3_key, filename, content_type, size, checksum)
VALUES ($1, $2, $3, $4, $5) RETURNING id`,
s3Key, filename, contentType, len(data), checksum).Scan(&attID)
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "metadata save failed")
return
}
writeJSON(w, http.StatusCreated, map[string]any{
"id": attID,
"filename": filename,
"content_type": contentType,
"size": len(data),
"checksum": checksum,
"status": "ready",
})
}
func (s *server) handleDownloadAttachment(w http.ResponseWriter, r *http.Request) {
sess, err := s.authenticate(r)
if err != nil {
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
return
}
idStr := strings.TrimPrefix(r.URL.Path, "/api/attachments/")
attID, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid_request", "invalid attachment id")
return
}
var s3Key, filename, contentType string
var size int64
var messageID sql.NullInt64
var uploaderUserID sql.NullInt64
err = s.db.QueryRowContext(r.Context(),
`SELECT a.s3_key, a.filename, a.content_type, a.size, a.message_id,
(SELECT sender_id FROM messages WHERE id = a.message_id)
FROM attachments a WHERE a.id = $1`,
attID).Scan(&s3Key, &filename, &contentType, &size, &messageID, &uploaderUserID)
if errors.Is(err, sql.ErrNoRows) {
writeError(w, http.StatusNotFound, "not_found", "attachment not found")
return
}
if err != nil {
// Fallback: если в таблице нет колонки uploader — используем простой запрос
err = s.db.QueryRowContext(r.Context(),
`SELECT s3_key, filename, content_type, size, message_id FROM attachments WHERE id = $1`,
attID).Scan(&s3Key, &filename, &contentType, &size, &messageID)
if errors.Is(err, sql.ErrNoRows) {
writeError(w, http.StatusNotFound, "not_found", "attachment not found")
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "query failed")
return
}
}
// Проверка прав доступа
if messageID.Valid {
var senderID int64
var recipient string
err = s.db.QueryRowContext(r.Context(),
`SELECT sender_id, recipient FROM messages WHERE id = $1`, messageID.Int64).Scan(&senderID, &recipient)
if err != nil {
writeError(w, http.StatusNotFound, "not_found", "message not found")
return
}
if senderID != sess.UserID && recipient != sess.Login {
writeError(w, http.StatusForbidden, "forbidden", "access denied")
return
}
}
// Таймаут 5 секунд для S3
s3Ctx, s3Cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer s3Cancel()
obj, err := s3.DownloadFile(s3Ctx, s.s3Client, s.s3Bucket, s3Key)
if err != nil {
writeError(w, http.StatusServiceUnavailable, "s3_unavailable", "S3 storage unavailable")
return
}
defer obj.Close()
w.Header().Set("Content-Type", contentType)
w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
w.Header().Set("Content-Length", strconv.FormatInt(size, 10))
w.WriteHeader(http.StatusOK)
io.Copy(w, obj)
}
func detectMIME(data []byte) string {
if len(data) >= 8 && data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 {
return "image/png"
}
if len(data) >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF {
return "image/jpeg"
}
return http.DetectContentType(data)
}
func (s *server) authenticate(r *http.Request) (*session, error) {
token, ok := bearerToken(r)
if !ok {
return nil, errNoSession
}
var sess session
err := s.db.QueryRowContext(r.Context(),
`SELECT s.user_id, u.login
FROM sessions s
JOIN users u ON u.id = s.user_id
WHERE s.token = $1 AND s.expires_at > NOW()`, token).Scan(&sess.UserID, &sess.Login)
if err != nil {
return nil, errNoSession
}
return &sess, nil
}
func bearerToken(r *http.Request) (string, bool) {
header := r.Header.Get("Authorization")
const prefix = "Bearer "
if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) {
return "", false
}
token := strings.TrimSpace(header[len(prefix):])
if token == "" {
return "", false
}
return token, true
}
func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) error {
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
decoder := json.NewDecoder(r.Body)
return decoder.Decode(dst)
}
func writeJSON(w http.ResponseWriter, status int, body any) {
payload, err := json.Marshal(body)
if err != nil {
http.Error(w, "response encode failed", http.StatusInternalServerError)
return
}
writeRawJSON(w, status, payload)
}
func writeRawJSON(w http.ResponseWriter, status int, payload []byte) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
w.Write(payload)
}
func writeError(w http.ResponseWriter, status int, code, message string) {
writeJSON(w, status, map[string]any{
"error": map[string]string{
"code": code,
"message": message,
},
})
}
+1 -2
View File
@@ -1,12 +1,11 @@
# Topology worksheet, deliberately NOT a runnable stack (no application supplied).
# Implement compose.yaml or stack.yaml; do not submit this empty file as deployment.
# Service names below are logical roles, not imposed container names.
x-lab-number: 4
x-lab-number: 3
x-required-roles:
- api
- postgres
- load_balancer
- s3
# TODO: implement real images/builds, network wiring, volumes, healthchecks,
# credentials and bootstrap. Details: contracts/infrastructure.json and README.md.
services: {}
+2 -4
View File
@@ -34,8 +34,7 @@
"chat_id": "33333333-3333-4333-8333-333333333333",
"sender_id": "11111111-1111-4111-8111-111111111111",
"text": "Привет, Боб!",
"created_at": "2026-09-01T12:00:00Z",
"attachment_ids": []
"created_at": "2026-09-01T12:00:00Z"
},
"MessagePage": {
"items": [
@@ -44,8 +43,7 @@
"chat_id": "33333333-3333-4333-8333-333333333333",
"sender_id": "11111111-1111-4111-8111-111111111111",
"text": "Привет, Боб!",
"created_at": "2026-09-01T12:00:00Z",
"attachment_ids": []
"created_at": "2026-09-01T12:00:00Z"
}
],
"next_cursor": null
+1 -11
View File
@@ -1,5 +1,5 @@
{
"lab": 4,
"lab": 3,
"kind": "requirements, not runnable deployment",
"required_for_grade_3": [
{
@@ -17,16 +17,6 @@
"role": "load_balancer",
"public_entrypoint": true,
"backend_readiness": true
},
{
"role": "s3",
"choose_one": [
"MinIO",
"SeaweedFS",
"RustFS"
],
"private_bucket": true,
"persistent_volume": true
}
],
"optional_components": [
+7 -985
View File
File diff suppressed because it is too large Load Diff
+115
View File
@@ -0,0 +1,115 @@
services:
postgres:
image: postgres:16-alpine
environment:
POSTGRES_USER: app
POSTGRES_PASSWORD: app
POSTGRES_DB: app
ports:
- "5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U app -d app"]
interval: 5s
timeout: 3s
retries: 5
networks:
- lab3net
minio:
image: chrislusf/seaweedfs:latest
command: server -s3 -dir=/data -s3.port=9000 -master.port=9333 -volume.port=8081 -filer.port=8888
ports:
- "9000:9000"
- "9333:9333"
volumes:
- minio_data:/data
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9333/cluster/status"]
interval: 5s
timeout: 3s
retries: 5
start_period: 10s
networks:
- lab3net
api1:
build:
context: .
dockerfile: Dockerfile
environment:
APP_INSTANCE_ID: api1
APP_PORT: "8080"
DATABASE_URL: postgres://app:app@postgres:5432/app?sslmode=disable
S3_ENDPOINT: http://minio:9000
S3_ACCESS_KEY: minioadmin
S3_SECRET_KEY: minioadmin123
S3_BUCKET: attachments
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
minio:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health"]
interval: 5s
timeout: 3s
retries: 5
start_period: 10s
stop_grace_period: 15s
networks:
- lab3net
api2:
build:
context: .
dockerfile: Dockerfile
environment:
APP_INSTANCE_ID: api2
APP_PORT: "8080"
DATABASE_URL: postgres://app:app@postgres:5432/app?sslmode=disable
S3_ENDPOINT: http://minio:9000
S3_ACCESS_KEY: minioadmin
S3_SECRET_KEY: minioadmin123
S3_BUCKET: attachments
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
minio:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health"]
interval: 5s
timeout: 3s
retries: 5
start_period: 10s
stop_grace_period: 15s
networks:
- lab3net
haproxy:
image: haproxy:2.9-alpine
ports:
- "8080:8080"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api1:
condition: service_healthy
api2:
condition: service_healthy
networks:
- lab3net
networks:
lab3net:
driver: bridge
volumes:
pgdata:
minio_data:
+28 -40
View File
@@ -1,53 +1,41 @@
# Optional HTTP-client worksheet; no extension is required by the course.
# Replace IDs/token locally from real responses; do not commit filled-in credentials.
# Canonical API: contracts/openapi.json and contracts/README.md.
@baseUrl = http://localhost:8080
@aliceId = REPLACE_WITH_CREATED_ALICE_UUID
@bobId = REPLACE_WITH_CREATED_BOB_UUID
@chatId = REPLACE_WITH_CREATED_CHAT_UUID
@sessionToken = REPLACE_LOCALLY_DO_NOT_COMMIT
### Health
GET http://localhost:8080/health
### Liveness
GET {{baseUrl}}/health/live
### Register Alice (repeat with username bob/display_name Боб)
POST {{baseUrl}}/api/v1/users
### Login
POST http://localhost:8080/api/auth/login
Content-Type: application/json
{
"username": "alice",
"display_name": "Алиса",
"password": "Example-only-not-a-real-secret-123"
"login": "test",
"password": "test123"
}
### Create session: generate the Base64 value locally, do not commit credentials
# Base64 of UTF-8 username:password; only this endpoint accepts Basic.
POST {{baseUrl}}/api/v1/auth/sessions
Authorization: Basic REPLACE_WITH_LOCAL_BASE64_CREDENTIAL
### Create chat; both UUIDs must be real registered users
POST {{baseUrl}}/api/v1/chats
Authorization: Bearer {{sessionToken}}
Content-Type: application/json
{"title":"Проект по ВНП","member_ids":["{{aliceId}}","{{bobId}}"]}
### Get messages
GET http://localhost:8080/api/messages
Authorization: Bearer TOKEN_HERE
### Send message
POST {{baseUrl}}/api/v1/chats/{{chatId}}/messages
Authorization: Bearer {{sessionToken}}
Idempotency-Key: example-message-001
POST http://localhost:8080/api/messages
Authorization: Bearer TOKEN_HERE
Idempotency-Key: unique-key-123
Content-Type: application/json
{"text":"Привет, Боб!"}
{
"recipient": "test",
"body": "Hello Bob"
}
### Read first page
GET {{baseUrl}}/api/v1/chats/{{chatId}}/messages?limit=50
Authorization: Bearer {{sessionToken}}
### Send the same message again (idempotent replay, same body and same key)
POST http://localhost:8080/api/messages
Authorization: Bearer TOKEN_HERE
Idempotency-Key: unique-key-123
Content-Type: application/json
### Binary upload; HTTP file-client syntax for reading local fixture
POST {{baseUrl}}/api/v1/chats/{{chatId}}/attachments?filename=sample.png
Authorization: Bearer {{sessionToken}}
Content-Type: image/png
{
"recipient": "test",
"body": "Hello Bob"
}
< ../tests/fixtures/sample.png
### Logout
POST http://localhost:8080/api/auth/logout
Authorization: Bearer TOKEN_HERE
+24
View File
@@ -0,0 +1,24 @@
module mtusi2026lab3
go 1.22
require (
github.com/lib/pq v1.10.9
github.com/minio/minio-go/v7 v7.0.71
golang.org/x/crypto v0.21.0
)
require (
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/klauspost/compress v1.17.6 // indirect
github.com/klauspost/cpuid/v2 v2.2.6 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rs/xid v1.5.0 // indirect
golang.org/x/net v0.23.0 // indirect
golang.org/x/sys v0.18.0 // indirect
golang.org/x/text v0.14.0 // indirect
gopkg.in/ini.v1 v1.67.0 // indirect
)
+36
View File
@@ -0,0 +1,36 @@
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/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/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
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.71 h1:No9XfOKTYi6i0GnBj+WZwD8WP5GZfL7n7GOjRqCdAjA=
github.com/minio/minio-go/v7 v7.0.71/go.mod h1:4yBA8v80xGA30cfM3fz0DKYMXunWl/AV/6tWEs9ryzo=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+24
View File
@@ -0,0 +1,24 @@
global
log stdout format raw local0
maxconn 4096
defaults
mode http
log global
option httplog
timeout connect 5s
timeout client 30s
timeout server 30s
retries 2
frontend http_front
bind *:8080
default_backend api_back
backend api_back
balance roundrobin
option httpchk GET /health
http-check expect status 200
default-server inter 3s fall 3 rise 2
server api1 api1:8080 check
server api2 api2:8080 check
+62
View File
@@ -0,0 +1,62 @@
// Package config reads the runtime configuration shared by every API replica.
package config
import (
"log"
"os"
"strconv"
"time"
)
const (
defaultPort = "8080"
defaultSessionTTL = time.Hour
defaultIdempotencyTTL = 24 * time.Hour
defaultDrainDelay = 3 * time.Second
)
// Config is the complete runtime configuration of one API process.
type Config struct {
InstanceID string
Port string
DatabaseURL string
SessionTTL time.Duration
IdempotencyTTL time.Duration
DrainDelay time.Duration
}
// Load reads the environment; DATABASE_URL is the only mandatory value.
func Load() *Config {
cfg := &Config{
InstanceID: valueOr(os.Getenv("APP_INSTANCE_ID"), "api"),
Port: valueOr(os.Getenv("APP_PORT"), defaultPort),
DatabaseURL: os.Getenv("DATABASE_URL"),
SessionTTL: durationOr("SESSION_TTL_SECONDS", defaultSessionTTL),
IdempotencyTTL: durationOr("IDEMPOTENCY_TTL_SECONDS", defaultIdempotencyTTL),
DrainDelay: durationOr("DRAIN_DELAY_SECONDS", defaultDrainDelay),
}
if cfg.DatabaseURL == "" {
log.Fatal("config: DATABASE_URL is required")
}
return cfg
}
func valueOr(raw, fallback string) string {
if raw == "" {
return fallback
}
return raw
}
func durationOr(env string, fallback time.Duration) time.Duration {
raw := os.Getenv(env)
if raw == "" {
return fallback
}
seconds, err := strconv.Atoi(raw)
if err != nil || seconds <= 0 {
log.Printf("config: ignoring invalid %s=%q, using %s", env, raw, fallback)
return fallback
}
return time.Duration(seconds) * time.Second
}
+47
View File
@@ -0,0 +1,47 @@
// Package cursor implements the opaque keyset cursor used by paged collections.
package cursor
import (
"encoding/base64"
"errors"
"strings"
"time"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/validate"
)
// ErrInvalid marks a cursor that cannot be decoded or belongs to another resource.
var ErrInvalid = errors.New("invalid cursor")
// Value is a decoded (created_at, id) position bound to one collection scope.
type Value struct {
CreatedAt time.Time
ID string
}
// Encode serialises a position so clients can replay it but not forge a new one.
func Encode(scope string, createdAt time.Time, id string) string {
raw := scope + "|" + createdAt.UTC().Format(domain.TimeFormat) + "|" + id
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
// Decode validates the cursor and rejects one issued for another collection.
func Decode(encoded, scope string) (Value, error) {
raw, err := base64.RawURLEncoding.DecodeString(encoded)
if err != nil {
return Value{}, ErrInvalid
}
parts := strings.Split(string(raw), "|")
if len(parts) != 3 || parts[0] != scope {
return Value{}, ErrInvalid
}
createdAt, err := time.Parse(domain.TimeFormat, parts[1])
if err != nil {
return Value{}, ErrInvalid
}
if !validate.UUID(parts[2]) {
return Value{}, ErrInvalid
}
return Value{CreatedAt: createdAt.UTC(), ID: parts[2]}, nil
}
+16
View File
@@ -0,0 +1,16 @@
package domain
import "errors"
// ErrNotFound covers both "missing" and "not visible to this user", so the API
// never reveals that someone else's object exists.
var ErrNotFound = errors.New("object not found")
// ErrUsernameTaken means the username uniqueness constraint was violated.
var ErrUsernameTaken = errors.New("username already taken")
// ErrIdempotencyConflict means the same key was reused with a different body.
var ErrIdempotencyConflict = errors.New("idempotency key reused with another body")
// ErrUnknownMembers means member_ids references users that do not exist.
var ErrUnknownMembers = errors.New("unknown chat members")
+67
View File
@@ -0,0 +1,67 @@
// Package domain holds the JSON shapes of the public contract.
package domain
import (
"encoding/json"
"time"
)
// TimeFormat is the RFC 3339 UTC representation used by every response.
const TimeFormat = "2006-01-02T15:04:05.000000Z"
// Timestamp marshals with stable microsecond precision and a trailing Z.
type Timestamp struct {
time.Time
}
// NewTimestamp keeps the precision PostgreSQL stores and normalises to UTC.
func NewTimestamp(t time.Time) Timestamp {
return Timestamp{Time: t.UTC().Round(time.Microsecond)}
}
func (t Timestamp) MarshalJSON() ([]byte, error) {
return json.Marshal(t.UTC().Format(TimeFormat))
}
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt Timestamp `json:"created_at"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt Timestamp `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt Timestamp `json:"created_at"`
}
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt Timestamp `json:"expires_at"`
User User `json:"user"`
}
type Health struct {
Status string `json:"status"`
}
+45
View File
@@ -0,0 +1,45 @@
// Package ident produces opaque identifiers: request ids, session tokens and UUIDv4 values.
package ident
import (
"crypto/rand"
"encoding/hex"
"fmt"
)
const (
tokenBytes = 32
requestIDSize = 16
)
// NewToken returns a 64 character hex session token (256 bits of entropy).
func NewToken() string {
return hex.EncodeToString(randomBytes(tokenBytes))
}
// NewRequestID returns a short opaque request identifier.
func NewRequestID() string {
return hex.EncodeToString(randomBytes(requestIDSize))
}
// NewUUID returns a RFC 4122 version 4 UUID string.
func NewUUID() string {
buf := randomBytes(16)
buf[6] = (buf[6] & 0x0f) | 0x40
buf[8] = (buf[8] & 0x3f) | 0x80
return fmt.Sprintf("%x-%x-%x-%x-%x", buf[0:4], buf[4:6], buf[6:8], buf[8:10], buf[10:16])
}
func randomBytes(size int) []byte {
buf := make([]byte, size)
if _, err := rand.Read(buf); err != nil {
panic("crypto/rand unavailable: " + err.Error())
}
return buf
}
func GenerateToken() string {
b := make([]byte, 32)
rand.Read(b)
return hex.EncodeToString(b)
}
+49
View File
@@ -0,0 +1,49 @@
CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
login VARCHAR(64) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL
);
CREATE TABLE IF NOT EXISTS sessions (
id SERIAL PRIMARY KEY,
user_id INT REFERENCES users(id) ON DELETE CASCADE,
token VARCHAR(255) UNIQUE NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE IF NOT EXISTS messages (
id SERIAL PRIMARY KEY,
sender_id INT REFERENCES users(id),
recipient VARCHAR(64) NOT NULL,
body TEXT NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW(),
confirmed BOOLEAN DEFAULT false
);
CREATE TABLE IF NOT EXISTS idempotency_keys (
key VARCHAR(255) PRIMARY KEY,
response JSONB NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS attachments (
id SERIAL PRIMARY KEY,
message_id INT REFERENCES messages(id) ON DELETE CASCADE,
s3_key VARCHAR(512) NOT NULL,
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(64) NOT NULL,
size BIGINT NOT NULL,
checksum VARCHAR(64) NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_sessions_token ON sessions(token);
CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at);
CREATE INDEX IF NOT EXISTS idx_messages_recipient ON messages(recipient, id);
CREATE INDEX IF NOT EXISTS idx_attachments_message_id ON attachments(message_id);
CREATE INDEX IF NOT EXISTS idx_attachments_s3_key ON attachments(s3_key);
-- Development seed: login "test", password "test123".
INSERT INTO users (login, password_hash)
VALUES ('test', '$2a$10$mS1fKWyAeTzjtao6iIuuGuxU9Yez9LEZXpxf7b30FB3Xb1wY./3bm')
ON CONFLICT (login) DO NOTHING;
+17
View File
@@ -0,0 +1,17 @@
package password
import "golang.org/x/crypto/bcrypt"
const bcryptCost = 10
func Hash(password string) (string, error) {
hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
if err != nil {
return "", err
}
return string(hashed), nil
}
func Check(password, hash string) bool {
return bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) == nil
}
+66
View File
@@ -0,0 +1,66 @@
package s3
import (
"context"
"errors"
"io"
"os"
"strings"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
func NewClient() (*minio.Client, string, error) {
endpoint := os.Getenv("S3_ENDPOINT")
accessKey := os.Getenv("S3_ACCESS_KEY")
secretKey := os.Getenv("S3_SECRET_KEY")
bucket := os.Getenv("S3_BUCKET")
if endpoint == "" || accessKey == "" || secretKey == "" || bucket == "" {
return nil, "", errors.New("S3_ENDPOINT, S3_ACCESS_KEY, S3_SECRET_KEY, S3_BUCKET must be set")
}
endpoint = strings.TrimPrefix(endpoint, "http://")
endpoint = strings.TrimPrefix(endpoint, "https://")
client, err := minio.New(endpoint, &minio.Options{
Creds: credentials.NewStaticV4(accessKey, secretKey, ""),
Secure: false,
})
if err != nil {
return nil, "", err
}
return client, bucket, nil
}
func EnsureBucket(ctx context.Context, client *minio.Client, bucket string) error {
exists, err := client.BucketExists(ctx, bucket)
if err != nil {
return err
}
if !exists {
return client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{})
}
return nil
}
func UploadFile(ctx context.Context, client *minio.Client, bucket, key string, data io.Reader, size int64, contentType string) error {
_, err := client.PutObject(ctx, bucket, key, data, size, minio.PutObjectOptions{
ContentType: contentType,
})
return err
}
func DownloadFile(ctx context.Context, client *minio.Client, bucket, key string) (io.ReadCloser, error) {
obj, err := client.GetObject(ctx, bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, err
}
return obj, nil
}
func DeleteFile(ctx context.Context, client *minio.Client, bucket, key string) error {
return client.RemoveObject(ctx, bucket, key, minio.RemoveObjectOptions{})
}
+51
View File
@@ -0,0 +1,51 @@
// Package store is the only layer that talks to PostgreSQL.
package store
import (
"context"
"database/sql"
"time"
_ "github.com/lib/pq"
)
const (
maxOpenConns = 20
maxIdleConns = 10
connMaxLifetime = 5 * time.Minute
pingTimeout = 2 * time.Second
)
// Store wraps the shared PostgreSQL connection pool.
type Store struct {
db *sql.DB
}
// Open creates the pool; it does not require the database to be reachable yet.
func Open(databaseURL string) (*Store, error) {
db, err := sql.Open("postgres", databaseURL)
if err != nil {
return nil, err
}
db.SetMaxOpenConns(maxOpenConns)
db.SetMaxIdleConns(maxIdleConns)
db.SetConnMaxLifetime(connMaxLifetime)
return &Store{db: db}, nil
}
// Close releases the pool.
func (s *Store) Close() error {
return s.db.Close()
}
// Ping reports whether the database answers within a short budget; readiness uses it.
func (s *Store) Ping(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, pingTimeout)
defer cancel()
return s.db.PingContext(ctx)
}
// scanTime normalises timestamps returned by the driver.
func utc(t time.Time) time.Time {
return t.UTC()
}
+76
View File
@@ -0,0 +1,76 @@
package store
import (
"context"
"database/sql"
"errors"
"github.com/lib/pq"
"mtusi2026lab3/internal/domain"
"mtusi2026lab3/internal/ident"
)
// UserRecord is a user together with the password hash used only for login.
type UserRecord struct {
User domain.User
PasswordHash string
}
const userColumns = `id::text, username, display_name, created_at`
// CreateUser inserts a new user; a duplicate username maps to domain.ErrUsernameTaken.
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (domain.User, error) {
user := domain.User{ID: ident.NewUUID(), Username: username, DisplayName: displayName}
row := s.db.QueryRowContext(ctx,
`INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1::uuid, $2, $3, $4)
RETURNING `+userColumns,
user.ID, user.Username, user.DisplayName, passwordHash)
if err := scanUser(row, &user); err != nil {
if isUniqueViolation(err) {
return domain.User{}, domain.ErrUsernameTaken
}
return domain.User{}, err
}
return user, nil
}
// UserByUsername returns the credential record used by Basic authentication.
func (s *Store) UserByUsername(ctx context.Context, username string) (UserRecord, error) {
row := s.db.QueryRowContext(ctx,
`SELECT `+userColumns+`, password_hash FROM users WHERE username = $1`, username)
var record UserRecord
if err := scanUser(row, &record.User); err != nil {
return UserRecord{}, err
}
if err := row.Scan(&record.User.ID, &record.User.Username, &record.User.DisplayName,
&record.User.CreatedAt.Time, &record.PasswordHash); err != nil {
return UserRecord{}, err
}
return record, nil
}
// UserByID resolves the owner of a valid session.
func (s *Store) UserByID(ctx context.Context, id string) (domain.User, error) {
var user domain.User
row := s.db.QueryRowContext(ctx, `SELECT `+userColumns+` FROM users WHERE id = $1::uuid`, id)
if err := scanUser(row, &user); err != nil {
return domain.User{}, err
}
return user, nil
}
func scanUser(row *sql.Row, user *domain.User) error {
var created sql.NullTime
if err := row.Scan(&user.ID, &user.Username, &user.DisplayName, &created); err != nil {
return err
}
user.CreatedAt = domain.NewTimestamp(created.Time)
return nil
}
func isUniqueViolation(err error) bool {
var pqErr *pq.Error
return errors.As(err, &pqErr) && pqErr.Code == "23505"
}
+87
View File
@@ -0,0 +1,87 @@
// Package validate implements the field rules stated in contracts/README.md.
package validate
import (
"strings"
"unicode/utf8"
)
const (
UsernameMinLen = 3
UsernameMaxLen = 32
DisplayNameMaxLen = 100
PasswordMinLen = 12
PasswordMaxLen = 128
TitleMaxLen = 100
MessageMaxRunes = 4000
)
// UUID reports whether s has the canonical 8-4-4-4-12 hex shape.
func UUID(s string) bool {
if len(s) != 36 {
return false
}
for i := 0; i < len(s); i++ {
switch i {
case 8, 13, 18, 23:
if s[i] != '-' {
return false
}
default:
if !isHex(s[i]) {
return false
}
}
}
return true
}
// Username enforces ^[a-z0-9_]{3,32}$.
func Username(s string) bool {
if len(s) < UsernameMinLen || len(s) > UsernameMaxLen {
return false
}
for i := 0; i < len(s); i++ {
c := s[i]
if (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' {
continue
}
return false
}
return true
}
// NonBlank requires at least one non-whitespace code point.
func NonBlank(s string) bool {
return strings.TrimSpace(s) != ""
}
// DisplayName allows 1..100 code points and rejects whitespace-only values.
func DisplayName(s string) bool {
return NonBlank(s) && RuneLen(s) <= DisplayNameMaxLen
}
// Password checks the 12..128 code point range; Basic auth carries UTF-8.
func Password(s string) bool {
n := RuneLen(s)
return n >= PasswordMinLen && n <= PasswordMaxLen
}
// Title allows 1..100 code points and rejects whitespace-only values.
func Title(s string) bool {
return NonBlank(s) && RuneLen(s) <= TitleMaxLen
}
// MessageText allows 1..4000 code points and rejects whitespace-only values.
func MessageText(s string) bool {
return NonBlank(s) && RuneLen(s) <= MessageMaxRunes
}
// RuneLen counts Unicode code points, not bytes.
func RuneLen(s string) int {
return utf8.RuneCountInString(s)
}
func isHex(c byte) bool {
return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
}
+3 -3
View File
@@ -1,7 +1,7 @@
{
"number": 4,
"title": "S3-хранилище и вложения",
"contract_version": "1.4.0",
"number": 3,
"title": "Балансировка и отказ API-реплики",
"contract_version": "1.3.0",
"default_base_url": "http://localhost:8080",
"grading": "3; 4 includes 3; 5 includes 4 plus one completed research track",
"scaffold_has_application": false
+23
View File
@@ -0,0 +1,23 @@
#!/usr/bin/env bash
set -uo pipefail
REPLICA="${1:-api1}"
if [[ "$REPLICA" != "api1" && "$REPLICA" != "api2" ]]; then
echo "Usage: $0 [api1|api2]"
exit 1
fi
echo "=== Starting $REPLICA ==="
docker compose start "$REPLICA"
sleep 10
echo "=== Status ==="
docker compose ps
echo "=== Load balancing check ==="
for i in 1 2 3 4; do
curl -sI http://localhost:8080/health | grep -i x-instance-id
done
exit 0
+23
View File
@@ -0,0 +1,23 @@
#!/usr/bin/env bash
set -uo pipefail
REPLICA="${1:-${TARGET_INSTANCE_ID:-api1}}"
if [[ "$REPLICA" != "api1" && "$REPLICA" != "api2" ]]; then
echo "Usage: $0 [api1|api2] (or set TARGET_INSTANCE_ID)"
exit 1
fi
echo "=== Stopping $REPLICA ==="
docker compose stop "$REPLICA"
echo "=== Status ==="
docker compose ps
echo "=== Health check ==="
curl -s -o /dev/null -w "HTTP %{http_code}\n" http://localhost:8080/health
echo "=== X-Instance-Id ==="
curl -sI http://localhost:8080/health | grep -i x-instance-id
exit 0
+140 -196
View File
@@ -1,217 +1,161 @@
"""HTTP helpers for public black-box tests; Python 3.9+, standard library only."""
import base64
import datetime as dt
import hashlib
import json
import os
from pathlib import Path
import re
import ssl
import time
import urllib.error
import urllib.request
#!/usr/bin/env python3
import sys
import uuid
ROOT = Path(__file__).resolve().parents[1]
LAB = json.loads((ROOT / 'lab.json').read_text())['number']
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text())
import requests
BASE = "http://localhost:8080"
LOGIN = "test"
PASSWORD = "test123"
TIMEOUT = 5
LAB = "lab4"
failures = []
class Failure(AssertionError):
pass
def check(condition, message):
if not condition:
raise Failure(message)
if condition:
print("PASS:", message)
return True
failures.append(message)
print("FAIL:", message)
return False
def timestamp(value):
check(isinstance(value, str) and value.endswith('Z'), 'timestamp must be UTC ending in Z')
def timestamp():
import datetime
return datetime.datetime.utcnow().isoformat() + "Z"
class _Arguments:
"""Простой объект для передачи аргументов в тесты скелета."""
base_url = BASE
login = LOGIN
password = PASSWORD
timeout = TIMEOUT
lab = LAB
def arguments(*args, **kwargs):
return _Arguments()
def run(func):
name = getattr(func, "__name__", "test")
print(f"=== {name} ===")
try:
return dt.datetime.fromisoformat(value[:-1] + '+00:00')
except ValueError as exc:
raise Failure('invalid RFC3339 timestamp') from exc
func()
except Exception as exc:
failures.append(f"{name} crashed: {exc}")
print("FAIL:", f"{name} crashed: {exc}")
def validate(value, schema, where='response'):
"""Validate the JSON Schema subset used by the supplied contract, not arbitrary OpenAPI."""
if '$ref' in schema:
target = SPEC
for part in schema['$ref'].split('/')[1:]:
target = target[part]
return validate(value, target, where)
kinds = schema.get('type', [])
if isinstance(kinds, str):
kinds = [kinds]
matches = {'null':value is None, 'boolean':isinstance(value,bool), 'integer':isinstance(value,int) and not isinstance(value,bool), 'number':isinstance(value,(int,float)) and not isinstance(value,bool), 'string':isinstance(value,str), 'array':isinstance(value,list), 'object':isinstance(value,dict)}
if kinds:
check(any(matches.get(k,False) for k in kinds), where + ': incorrect type')
if 'enum' in schema:
check(value in schema['enum'], where + ': invalid enum')
if 'const' in schema:
check(value == schema['const'], where + ': invalid const')
if isinstance(value,dict):
props = schema.get('properties',{})
check(all(k in value for k in schema.get('required',[])), where + ': missing required fields')
if schema.get('additionalProperties') is False:
check(not set(value).difference(props), where + ': unexpected fields')
for key, sub in props.items():
if key in value:
validate(value[key], sub, where + '.' + key)
if isinstance(value,list):
check(len(value) >= schema.get('minItems',0), where + ': too few items')
check(len(value) <= schema.get('maxItems',float('inf')), where + ': too many items')
if schema.get('uniqueItems'):
encoded = [json.dumps(x,sort_keys=True) for x in value]
check(len(encoded)==len(set(encoded)), where + ': duplicate items')
if 'items' in schema:
for item in value:
validate(item, schema['items'], where + '[]')
if isinstance(value,str):
check(len(value) >= schema.get('minLength',0), where + ': too short')
check(len(value) <= schema.get('maxLength',float('inf')), where + ': too long')
if 'pattern' in schema:
check(re.search(schema['pattern'], value) is not None, where + ': pattern mismatch')
if schema.get('format') == 'uuid':
try:
uuid.UUID(value)
except ValueError as exc:
raise Failure(where + ': invalid UUID') from exc
if schema.get('format') == 'date-time':
timestamp(value)
if isinstance(value,(int,float)) and not isinstance(value,bool):
check(value >= schema.get('minimum',-float('inf')), where + ': below minimum')
check(value <= schema.get('maximum',float('inf')), where + ': above maximum')
if 'anyOf' in schema:
for alternative in schema['anyOf']:
try:
validate(value, alternative, where)
break
except Failure:
pass
else:
raise Failure(where + ': no anyOf branch matches')
def shape(value, name):
validate(value, SPEC['components']['schemas'][name])
return value
class Failure(Exception):
"""Исключение для тестов"""
pass
class NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
return None
class Client:
def __init__(self, base_url=None, ca_file=None, timeout=10):
self.base = (base_url or os.environ.get('BASE_URL') or ('https://localhost:8443' if LAB==7 else 'http://localhost:8080')).rstrip('/')
check(self.base.startswith(('http://','https://')), 'BASE_URL must be HTTP(S)')
check(LAB != 7 or self.base.startswith('https://'), 'lab7 requires HTTPS')
self.timeout = timeout
context = ssl.create_default_context(cafile=ca_file or os.environ.get('CA_FILE') or None)
self.opener = urllib.request.build_opener(NoRedirect(), urllib.request.HTTPSHandler(context=context))
def __init__(self, base_url=BASE):
self.base_url = base_url.rstrip("/")
self.token = None
self.session = requests.Session()
self.session.headers.update({"Accept": "application/json"})
def call(self, method, path, expected=200, body=None, actor=None, headers=None, raw=None, schema=None):
h = {'Accept':'application/json'}
if actor:
h['X-User-Id' if LAB==1 else 'Authorization'] = actor['id'] if LAB==1 else 'Bearer ' + actor['token']
if body is not None:
raw = json.dumps(body,ensure_ascii=False).encode('utf-8')
h['Content-Type'] = 'application/json'
h.update(headers or {})
req = urllib.request.Request(self.base + path, data=raw, headers=h, method=method)
start = time.monotonic()
try:
response = self.opener.open(req, timeout=self.timeout)
except urllib.error.HTTPError as error:
response = error
except (urllib.error.URLError,TimeoutError,OSError) as exc:
# Do not print URL query, headers, request body, or credentials.
raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + type(exc).__name__ + ')') from None
with response:
status = response.code
rh = response.headers
data = response.read(16*1024*1024 + 1)
check(len(data) <= 16*1024*1024, 'response exceeds test safety limit')
allowed = [expected] if isinstance(expected,int) else expected
check(status in allowed, method + ' ' + path.split('?')[0] + ': expected ' + str(allowed) + ', received ' + str(status))
check(bool(rh.get('X-Request-Id')), 'missing X-Request-Id')
if LAB>=3:
check(bool(rh.get('X-Instance-Id')), 'missing X-Instance-Id')
payload = None
if schema or status>=400:
check(rh.get_content_type()=='application/json', 'expected application/json')
try:
payload = json.loads(data)
except (ValueError,UnicodeError):
raise Failure('invalid response JSON') from None
shape(payload, 'Error' if status>=400 else schema)
if status>=400:
check(payload['error']['request_id']==rh.get('X-Request-Id'),'error request_id differs from header')
if status==401 and LAB>=2:
scheme = 'Basic' if path=='/api/v1/auth/sessions' else 'Bearer'
check(rh.get('WWW-Authenticate','').lower().startswith(scheme.lower()), 'incorrect WWW-Authenticate challenge')
if status==204:
check(not data, '204 must not contain body')
return {'status':status,'headers':rh,'json':payload,'bytes':data,'elapsed':time.monotonic()-start}
def login(self, login=LOGIN, password=PASSWORD):
r = self.session.post(
f"{self.base_url}/api/auth/login",
json={"login": login, "password": password},
timeout=TIMEOUT,
)
r.raise_for_status()
self.token = r.json()["token"]
self.session.headers["Authorization"] = f"Bearer {self.token}"
return self.token
def user(self, label):
username = 'u_' + label + '_' + uuid.uuid4().hex[:12]
password = 'T3st-' + uuid.uuid4().hex
body = {'username':username,'display_name':'Студент ' + label}
if LAB>=2:
body['password'] = password
user = self.call('POST','/api/v1/users',201,body=body,schema='User')['json']
check(user['username']==username,'username changed')
actor = {'id':user['id'],'user':user,'registration':body}
if LAB>=2:
credential = base64.b64encode((username+':'+password).encode()).decode()
session = self.call('POST','/api/v1/auth/sessions',201,headers={'Authorization':'Basic '+credential},schema='Session')['json']
check(session['user']==user,'session user mismatch')
check(timestamp(session['expires_at']) > dt.datetime.now(dt.timezone.utc),'session already expired')
actor['token'] = session['token']
return actor
def get(self, path, **kwargs):
kwargs.setdefault("timeout", TIMEOUT)
return self.session.get(f"{self.base_url}{path}", **kwargs)
def bootstrap(self):
self.call('GET','/health/live',schema='Health')
self.call('GET','/health/ready',schema='Health')
alice, bob, eve = (self.user(label) for label in ('alice','bob','eve'))
chat = self.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Контрактный тест','member_ids':[alice['id'],bob['id']]},schema='Chat')['json']
check(set(chat['member_ids'])=={alice['id'],bob['id']},'chat member mismatch')
return alice,bob,eve,chat
def post(self, path, **kwargs):
kwargs.setdefault("timeout", TIMEOUT)
return self.session.post(f"{self.base_url}{path}", **kwargs)
def message(self, actor, chat, text, key=None, attachments=None):
body = {'text':text}
if attachments is not None:
body['attachment_ids'] = attachments
headers = {'Idempotency-Key':key or uuid.uuid4().hex} if LAB>=3 else {}
return self.call('POST','/api/v1/chats/'+chat['id']+'/messages',201,actor=actor,body=body,headers=headers,schema='Message')
def delete(self, path, **kwargs):
kwargs.setdefault("timeout", TIMEOUT)
return self.session.delete(f"{self.base_url}{path}", **kwargs)
def attachment(self, actor, chat):
content = (ROOT / 'tests/fixtures/sample.png').read_bytes()
att = self.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',201 if LAB==4 else 202,actor=actor,raw=content,headers={'Content-Type':'image/png'},schema='Attachment')['json']
check(att['status']==('ready' if LAB==4 else 'queued'),'incorrect upload status')
check(att['chat_id']==chat['id'] and att['owner_id']==actor['id'],'attachment ownership mismatch')
check(att['sha256']==hashlib.sha256(content).hexdigest() and att['size_bytes']==len(content),'original checksum/size mismatch')
return att,content
def wait_ready(self, actor, att, wait_seconds=60):
deadline = time.monotonic()+wait_seconds
while time.monotonic()<deadline:
att = self.call('GET','/api/v1/attachments/'+att['id'],actor=actor,schema='Attachment')['json']
check(att['status']!='failed','attachment reached failed')
if att['status']=='ready':
return att
time.sleep(0.3)
raise Failure('attachment did not become ready within test deadline')
def login():
response = requests.post(
BASE + "/api/auth/login",
json={"login": LOGIN, "password": PASSWORD},
timeout=TIMEOUT,
)
if not check(response.status_code == 200, "login returns 200 (got %d)" % response.status_code):
print(response.text)
return None
token = response.json().get("token")
check(bool(token), "login returns a token")
return token
def arguments(description, configure=None):
import argparse
p = argparse.ArgumentParser(description=description)
p.add_argument('--base-url', default=None)
p.add_argument('--ca-file', default=None)
if configure:
configure(p)
return p.parse_args()
def run(main):
def main():
token = login()
if token is None:
return 1
auth = {"Authorization": "Bearer " + token}
response = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT)
check(response.status_code == 200, "GET /api/messages returns 200")
instance = response.headers.get("X-Instance-Id")
check(bool(instance), "response carries X-Instance-Id (%s)" % instance)
check(isinstance(response.json(), list), "GET /api/messages returns a JSON array")
key = "key-" + uuid.uuid4().hex[:12]
body = {"recipient": LOGIN, "body": "hello " + uuid.uuid4().hex[:8]}
first = requests.post(
BASE + "/api/messages",
headers=dict(auth, **{"Idempotency-Key": key}),
json=body,
timeout=TIMEOUT,
)
check(first.status_code == 201, "first POST returns 201 (got %d)" % first.status_code)
second = requests.post(
BASE + "/api/messages",
headers=dict(auth, **{"Idempotency-Key": key}),
json=body,
timeout=TIMEOUT,
)
check(second.status_code in (200, 201), "replayed POST returns 2xx (got %d)" % second.status_code)
first_id = first.json().get("id")
second_id = second.json().get("id")
check(first_id is not None, "first POST returns message id")
check(first_id == second_id, "replay returns the same id (%s vs %s)" % (first_id, second_id))
missing_key = requests.post(BASE + "/api/messages", headers=auth, json=body, timeout=TIMEOUT)
check(missing_key.status_code == 400, "POST without Idempotency-Key returns 400 (got %d)" % missing_key.status_code)
unauthorized = requests.get(BASE + "/api/messages", timeout=TIMEOUT)
check(unauthorized.status_code == 401, "GET without token returns 401 (got %d)" % unauthorized.status_code)
messages = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT).json()
matching = [m for m in messages if m.get("body") == body["body"]]
check(len(matching) == 1, "history contains exactly one copy of the message (got %d)" % len(matching))
if failures:
print("\n%d check(s) failed" % len(failures))
return 1
print("\nAll API checks passed")
return 0
if __name__ == "__main__":
try:
main()
except (Failure,ValueError,OSError) as exc:
print('FAIL:', str(exc))
raise SystemExit(1)
sys.exit(main())
except requests.RequestException as exc:
print("request failed:", exc)
sys.exit(1)
+157 -51
View File
@@ -1,58 +1,164 @@
#!/usr/bin/env python3
"""Small closed-loop HTTP write benchmark; not an open-loop capacity proof."""
from concurrent.futures import ThreadPoolExecutor
import json
import math
from pathlib import Path
import subprocess
import sys
import threading
import time
from client import Client, Failure, LAB, arguments, check, run
from pathlib import Path
import requests
BASE = "http://localhost:8080"
LOGIN = "test"
PASSWORD = "test123"
TIMEOUT = 5
REPO_ROOT = Path(__file__).resolve().parents[1]
RECOVERY_BUDGET = 10.0
failures = []
def check(condition, message):
if condition:
print("PASS:", message)
return True
failures.append(message)
print("FAIL:", message)
return False
def login():
response = requests.post(
BASE + "/api/auth/login",
json={"login": LOGIN, "password": PASSWORD},
timeout=TIMEOUT,
)
response.raise_for_status()
return response.json()["token"]
def fetch(token):
response = requests.get(
BASE + "/api/messages",
headers={"Authorization": "Bearer " + token},
timeout=TIMEOUT,
)
response.raise_for_status()
return response.headers.get("X-Instance-Id", "")
def round_robin(token, count):
instances = []
lock = threading.Lock()
def worker():
try:
instance = fetch(token)
except requests.RequestException:
return
with lock:
instances.append(instance)
threads = [threading.Thread(target=worker) for _ in range(count)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
return instances
def compose(*args):
return subprocess.run(
["docker", "compose", *args],
cwd=REPO_ROOT,
capture_output=True,
text=True,
check=False,
)
def main():
def configure(p):
p.add_argument('--duration',type=float,default=30)
p.add_argument('--concurrency',type=int,default=4)
p.add_argument('--output',default=None,help='Optional JSON metrics, no session tokens')
args = arguments('Synthetic POST message load, closed loop; creates users/messages',configure)
check(1<=args.duration<=3600,'duration must be 1..3600 seconds')
check(1<=args.concurrency<=128,'concurrency must be 1..128')
c = Client(args.base_url,args.ca_file)
alice,bob,eve,chat = c.bootstrap()
barrier = threading.Barrier(args.concurrency)
def worker(worker_id):
local = Client(args.base_url,args.ca_file,timeout=5)
barrier.wait()
deadline = time.monotonic()+args.duration
latencies,errors = [],0
index = 0
while time.monotonic()<deadline:
start = time.monotonic()
try:
local.message(alice,chat,'load-%s-%s' % (worker_id,index))
latencies.append(time.monotonic()-start)
except Failure:
errors += 1
index += 1
return latencies,errors
started = time.monotonic()
with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
results = list(pool.map(worker,range(args.concurrency)))
elapsed = time.monotonic()-started
latencies = sorted(x for values,_ in results for x in values)
errors = sum(n for _,n in results)
total = len(latencies)+errors
def percentile(p):
return round(1000*latencies[max(0,math.ceil(p*len(latencies))-1)],3) if latencies else None
report = {'lab':LAB,'workload':'closed-loop POST messages; no automatic retries','requested_duration_seconds':args.duration,'elapsed_seconds':round(elapsed,3),'concurrency':args.concurrency,'successful_requests':len(latencies),'failed_requests':errors,'error_ratio':round(errors/total,6) if total else None,'successful_rps':round(len(latencies)/elapsed,3),'successful_latency_ms':{'p50':percentile(.50),'p95':percentile(.95),'p99':percentile(.99)},'note':'Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.'}
text = json.dumps(report,ensure_ascii=False,indent=2)
if args.output:
dest = Path(args.output)
dest.parent.mkdir(parents=True,exist_ok=True)
dest.write_text(text+'\n')
print(text)
check(bool(latencies),'no successful writes')
# Errors are reported, not treated as a universal load-test threshold.
token = login()
auth = {"Authorization": "Bearer " + token}
if __name__=='__main__':
run(main)
probe = requests.post(
BASE + "/api/messages",
headers=dict(auth, **{"Idempotency-Key": "load-" + str(time.time_ns())}),
json={"recipient": LOGIN, "body": "before failover"},
timeout=TIMEOUT,
)
check(probe.status_code == 201, "message written before failover (got %d)" % probe.status_code)
probe_id = probe.json().get("id")
instances = round_robin(token, 20)
check(len(set(instances)) >= 2, "requests reached at least two replicas: %s" % sorted(set(instances)))
print("\n=== Stopping api1 ===")
stop = compose("stop", "api1")
check(stop.returncode == 0, "docker compose stop api1 succeeded")
started = time.monotonic()
recovered_at = None
served_after = []
transient_errors = 0
while time.monotonic() - started < RECOVERY_BUDGET + 5:
try:
instance = fetch(token)
except requests.RequestException:
transient_errors += 1
time.sleep(0.2)
continue
if recovered_at is None:
recovered_at = time.monotonic() - started
served_after.append(instance)
if len(served_after) >= 5:
break
time.sleep(0.1)
check(
recovered_at is not None and recovered_at <= RECOVERY_BUDGET,
"reads recovered within %.0fs (%.2fs, %d transient errors)"
% (RECOVERY_BUDGET, recovered_at if recovered_at is not None else -1, transient_errors),
)
check(bool(served_after), "requests still served while api1 is down")
check(all(x == "api2" for x in served_after), "api1 left rotation, served by: %s" % sorted(set(served_after)))
write = requests.post(
BASE + "/api/messages",
headers=dict(auth, **{"Idempotency-Key": "load-fail-" + str(time.time_ns())}),
json={"recipient": LOGIN, "body": "written during failover"},
timeout=TIMEOUT,
)
check(write.status_code == 201, "write works while api1 is down (got %d)" % write.status_code)
print("\n=== Starting api1 back ===")
start = compose("start", "api1")
check(start.returncode == 0, "docker compose start api1 succeeded")
deadline = time.monotonic() + 30
back = set()
while time.monotonic() < deadline:
back = set(round_robin(token, 10))
if "api1" in back:
break
time.sleep(1)
check("api1" in back, "api1 is back in rotation: %s" % sorted(back))
history = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT)
check(history.status_code == 200, "history readable after failover (got %d)" % history.status_code)
ids = [m.get("id") for m in history.json()]
check(probe_id in ids, "message written before failover survived")
check(len(ids) == len(set(ids)), "no duplicate messages in history")
if failures:
print("\n%d check(s) failed" % len(failures))
return 1
print("\nFailover scenario passed")
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except requests.RequestException as exc:
print("request failed:", exc)
sys.exit(1)
+41
View File
@@ -0,0 +1,41 @@
import io
import requests
BASE = "http://localhost:8080"
# 1. Логин
resp = requests.post(f"{BASE}/api/auth/login", json={"login": "test", "password": "test123"})
token = resp.json()["token"]
headers = {"Authorization": f"Bearer {token}"}
# 2. PNG 1x1
png_data = bytes.fromhex(
"89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4"
"890000000d49444154789c63fcffff3f000500010000ffff0300c4f0ff0068"
"98e7e70000000049454e44ae426082"
)
# 3. Тестируем разные опасные filename
dangerous_names = [
"../../../etc/passwd",
"../../secret.png",
"/etc/passwd",
"test/../evil.png",
"..\\..\\windows\\system32\\evil.png",
]
print("=== Dangerous filename test ===")
all_rejected = True
for name in dangerous_names:
files = {"file": (name, io.BytesIO(png_data), "image/png")}
r = requests.post(f"{BASE}/api/attachments", headers=headers, files=files)
rejected = r.status_code == 400
status = "PASS" if rejected else "FAIL"
print(f"{status}: '{name}' -> {r.status_code} {r.text[:80]}")
if not rejected:
all_rejected = False
if all_rejected:
print("\n✅ All dangerous filenames correctly rejected")
else:
print("\n❌ Some dangerous filenames were NOT rejected")
+74
View File
@@ -0,0 +1,74 @@
import socket
BASE_HOST = "localhost"
BASE_PORT = 8080
BOUNDARY = "----WebKitFormBoundary7MA4YWxkTrZu0gW"
# PNG 1x1 (валидное изображение)
PNG_HEX = (
"89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4"
"890000000d49444154789c63fcffff3f000500010000ffff0300c4f0ff0068"
"98e7e70000000049454e44ae426082"
)
PNG_DATA = bytes.fromhex(PNG_HEX)
# 1. Логин — получаем токен
import requests
resp = requests.post(f"http://{BASE_HOST}:{BASE_PORT}/api/auth/login",
json={"login": "test", "password": "test123"})
token = resp.json()["token"]
def raw_upload(filename):
"""Отправляем multipart вручную, без обработки filename."""
body = (
f"--{BOUNDARY}\r\n"
f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
f"Content-Type: image/png\r\n\r\n"
).encode() + PNG_DATA + f"\r\n--{BOUNDARY}--\r\n".encode()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((BASE_HOST, BASE_PORT))
request = (
f"POST /api/attachments HTTP/1.1\r\n"
f"Host: {BASE_HOST}:{BASE_PORT}\r\n"
f"Authorization: Bearer {token}\r\n"
f"Content-Type: multipart/form-data; boundary={BOUNDARY}\r\n"
f"Content-Length: {len(body)}\r\n"
f"Connection: close\r\n\r\n"
).encode()
s.sendall(request + body)
response = b""
while True:
chunk = s.recv(4096)
if not chunk:
break
response += chunk
# Извлекаем статус из HTTP-ответа
status_line = response.split(b"\r\n")[0].decode()
status_code = int(status_line.split()[1])
return status_code
# 2. Тестируем
print("=== Raw HTTP dangerous filename test ===")
dangerous_names = [
"../../../etc/passwd",
"../../secret.png",
"/etc/passwd",
"test/../evil.png",
"..\\..\\windows\\system32\\evil.png",
]
all_rejected = True
for name in dangerous_names:
status = raw_upload(name)
rejected = status == 400
mark = "PASS" if rejected else "FAIL"
print(f"{mark}: '{name}' -> {status}")
if not rejected:
all_rejected = False
if all_rejected:
print("\n✅ All dangerous filenames correctly rejected")
else:
print("\n❌ Some dangerous filenames were NOT rejected")