Перенес изменения

This commit is contained in:
Grbisba
2026-11-13 11:22:22 +03:00
parent 276dbdad8a
commit ce035c8528
122 changed files with 9357 additions and 28 deletions
+29 -16
View File
@@ -1,23 +1,36 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# scripts/bootstrap.sh creates ignored .env.lab5 with random synthetic credentials.
# This example documents actual Compose inputs; it contains no live secrets.
POSTGRES_PASSWORD=replace-with-local-postgres-password
REDIS_PASSWORD=replace-with-local-redis-password
HOST_PORT=18085
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_REGION=us-east-1
API_CPUS=1
API_MEMORY=512m
POSTGRES_MAX_CONNECTIONS=8
APPLICATION_LOG_LEVEL=warn
SESSION_TTL_SECONDS=3600
API_IMAGE=mtusi-messenger:lab5
# Session TTL defaults to 3600; use >=300 for smoke/persistence.
# Message idempotency retention is fixed at 24 hours; API never runs migrations.
# S3 credentials are generated locally by scripts/bootstrap-storage.py.
# For a custom bucket, also export S3_BUCKET before make up: the credential
# bootstrap reads the process environment, while Compose reads .env.lab5.
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
# Runtime values fixed in compose.yaml (not configurable through this file):
# S3_ENDPOINT=http://s3:9000
# S3_REGION=us-east-1
# S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access
# S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
# Bounded attachment request lifetime; grace must exceed twice this duration.
UPLOAD_TIMEOUT=120s
RECONCILE_GRACE_PERIOD=1h
# SeaweedFS image and persistent bucket bootstrap are pinned in compose.yaml.
# API has four upload slots and one decoder per replica, GOMEMLIMIT=384MiB.
# Planned lab5 async pipeline settings; the ported lab4 application does not use these yet.
BROKER_URL_FILE=/run/secrets/broker_url
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
+1
View File
@@ -30,3 +30,4 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
/.ignore/
+32
View File
@@ -0,0 +1,32 @@
# syntax=docker/dockerfile:1
FROM --platform=$BUILDPLATFORM golang:1.27.2-alpine3.23@sha256:9e45f0eb4a63ed37ad6e604950407558b7c738e34e015ae77a5d4ad369cde079 AS build
WORKDIR /src
COPY service/go.mod service/go.sum ./
RUN go mod download
COPY service/ ./
ARG TARGETOS
ARG TARGETARCH
RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
go build -mod=readonly -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/app
FROM alpine:3.23.6@sha256:85fe1e81d6758c208f3e1eed4338a1997e19d4be002d4dd32d3100c9a8c010a0
COPY --from=build --chmod=0555 /out/messenger /usr/local/bin/messenger
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_SHUTDOWN_TIMEOUT=8s
USER 65532:65532
EXPOSE 8080
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O /dev/null "http://127.0.0.1:${APP_PORT}/health/ready" || exit 1
ENTRYPOINT ["/usr/local/bin/messenger"]
+86 -3
View File
@@ -1,13 +1,24 @@
SHELL := /bin/bash
GO ?= go
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
BASE_URL ?= http://localhost:18085
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
OPENAPI_SPEC := contracts/openapi.json
GEN_OUTPUT := service/internal/gen/contracts/types.gen.go
GEN_PACKAGE := contracts
OAPI_CODEGEN ?= $(shell $(GO) env GOPATH)/bin/oapi-codegen
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover openapi-generate certs key-gen create-dir gen-private-key gen-public-key gen-key gen-crt
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "up/down: lab5 stand (ported lab4 application); build/vet: Go checks"
@echo "test: lab5 API smoke (requires async implementation); test-go/test-storage: existing Go checks"
@echo "restart/restore/rolling-update: infrastructure actions; benchmark/load: synthetic traffic"
@echo "check/validate: lab5 contracts; test-persistence/test-failover: explicit ACTION_SCRIPT hooks"
@echo "reconcile/reconcile-apply: storage consistency"
@echo "openapi-generate: generate types from lab5 contract; key-gen/certs: local keys"
check:
$(PYTHON) scripts/check_contract.py
@@ -28,3 +39,75 @@ test-persistence:
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)
openapi-generate:
@mkdir -p $(dir $(GEN_OUTPUT))
@echo "Generating Go types from $(OPENAPI_SPEC)..."
@set -o pipefail; \
$(PYTHON) scripts/generate-types.py | \
$(OAPI_CODEGEN) -generate types -package $(GEN_PACKAGE) -o $(GEN_OUTPUT) /dev/stdin
key-gen: gen-public-key
create-dir:
@mkdir -p certs
gen-private-key: | create-dir
@openssl genrsa -out certs/private_key.pem 2048
gen-public-key: gen-private-key
@openssl rsa -in certs/private_key.pem -pubout -outform PEM -out certs/public_key.pem
certs: gen-crt
gen-key: | create-dir
@openssl genrsa -out ./certs/server.key 2048
gen-crt: gen-key
@openssl req -new -x509 -key ./certs/server.key -out ./certs/server.crt -days 365
.PHONY: up down test-go
up:
./scripts/bootstrap.sh
./scripts/compose.sh up -d --build --wait --wait-timeout 120
down:
./scripts/compose.sh down
test-go:
cd service && TEST_BASE_URL="$(BASE_URL)" $(GO) test -race -count=1 -v ./...
RATE ?= 100
DURATION ?= 30s
BENCH_ARGS ?=
.PHONY: build vet restart restore rolling-update benchmark test-storage
build:
cd service && $(GO) build ./...
@mkdir -p bin
cd service && $(GO) build -o ../bin/benchmark ./cmd/benchmark
vet:
cd service && $(GO) vet ./...
restart:
./scripts/restart.sh
restore:
./scripts/compose.sh up -d --wait --wait-timeout 90 --no-recreate api lb
rolling-update:
./scripts/rolling-update.sh
benchmark: build
./bin/benchmark -base-url "$(BASE_URL)" -rate "$(RATE)" -duration "$(DURATION)" $(BENCH_ARGS)
test-storage:
./scripts/test-storage.sh
.PHONY: reconcile reconcile-apply
reconcile:
./scripts/compose.sh run --rm -T operator storage reconcile
reconcile-apply:
./scripts/compose.sh run --rm -T operator storage reconcile --apply
+25 -9
View File
@@ -2,7 +2,7 @@
Отделить приём файла от тяжёлой обработки, корректно переживать повторную доставку и остановку worker.
Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен.
В репозиторий перенесена рабочая основа lab4: Go-приложение, миграции, Dockerfile и стенд с PostgreSQL, Redis, S3 (SeaweedFS) и HAProxy. Задание, контракт и публичные проверки относятся к lab5; очередь и worker ещё предстоит реализовать. Язык и framework свободные; UI не обязателен.
[Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md)
@@ -48,21 +48,37 @@
## Как начать и проверить
```sh
# Работает прямо в skeleton, Python 3.9+; приложение не запускается:
# Проверка структуры и контрактов, Python 3.9+; приложение не запускается:
make check
# После реализации запустите свой сервер/стенд по REPORT.md.
# По умолчанию тест использует http://localhost:8080.
# Сборка приложения (Go 1.27+) и статический анализ:
make build
make vet
# Создание локальных настроек/ключей и запуск стенда (Docker Compose):
make up
curl --fail http://localhost:18085/health/ready
# Публичные проверки lab5; полностью заработают после реализации async pipeline:
make test
# Остановка стенда с сохранением данных:
make down
```
`.env.example`, `compose.example.yaml` и `contracts/infrastructure.json` описывают настройки и роли компонентов. **compose.example.yaml — список ролей с пустым services, не запускаемый стенд.** Реализуйте свой `compose.yaml`/`stack.yaml`, закрепите версии образов, заполните локальный `.env` и опишите bootstrap/миграции. Все зависимости поднимаются из этого репозитория; ссылка «у меня БД уже установлена» не заменяет воспроизводимость.
`make up` выполняет `scripts/bootstrap.sh`: создаёт игнорируемые `.env.lab5` и `secrets/lab5/` с новыми локальными паролями и ключами, сохраняя существующие при повторном запуске. Пароли и ключи из lab4 не копируются. `.env.example` документирует настройки стенда; параметры будущей очереди пока не используются. Для смены порта измените `HOST_PORT` в `.env.lab5` и передавайте соответствующий `BASE_URL` командам Makefile.
Compose-проект называется `mtusi2026lab5`, использует собственные volumes и по умолчанию доступен на `http://localhost:18085`, поэтому может работать одновременно с lab4. PostgreSQL мигрируется отдельным одноразовым сервисом, S3 bucket инициализируется перед запуском API. Ключи `make key-gen` и `make certs` создаются отдельно в `certs/`; для Compose ключи создаёт bootstrap.
**Это перенос основы, а не готовая lab5:** upload пока синхронный и возвращает `201`, брокера и worker нет. Контракт lab5 требует `202`, фоновой обработки и вариантов изображения, поэтому публичный smoke сейчас не должен проходить полностью. Существующие Go-проверки перенесены вместе с приложением и доступны через `make test-go` и `make test-storage`. `make openapi-generate` использует контракт lab5; при переносе сохранены сгенерированные типы lab4.
`compose.yaml` — запускаемый стенд. **compose.example.yaml — список ролей с пустым services, не запускаемый стенд.** `contracts/infrastructure.json` задаёт требования lab5; расширьте стенд брокером и worker при реализации задания. Все зависимости поднимаются из этого репозитория; ссылка «у меня БД уже установлена» не заменяет воспроизводимость.
```sh
# Compose-вариант после реализации:
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# Дождитесь /health/ready; затем make test.
# Прямое управление тем же стендом:
./scripts/bootstrap.sh
./scripts/compose.sh config --quiet
./scripts/compose.sh up -d --build --wait --wait-timeout 120
# Для Swarm укажите эквивалентные build/push/deploy-команды в REPORT.md.
```
+182
View File
@@ -0,0 +1,182 @@
name: mtusi2026lab5
x-api: &api
image: ${API_IMAGE:-mtusi-messenger:lab5}
build: .
restart: unless-stopped
cpus: ${API_CPUS:-1}
mem_limit: ${API_MEMORY:-512m}
environment: &environment
APP_ENABLED: "true"
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_READ_TIMEOUT: 125s
APP_WRITE_TIMEOUT: 125s
APP_IDLE_TIMEOUT: 60s
APP_SHUTDOWN_TIMEOUT: 8s
APPLICATION_LOG_LEVEL: ${APPLICATION_LOG_LEVEL:-warn}
APPLICATION_ENVIRONMENT: prod
APPLICATION_SHUTDOWN_TIMEOUT: 8s
POSTGRES_HOST: postgres
POSTGRES_PORT: 5432
POSTGRES_USER: messenger
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Run scripts/bootstrap.sh}
POSTGRES_DATABASE: messenger
POSTGRES_VERSION_TABLE: versions
POSTGRES_RUN_MIGRATIONS: "false"
POSTGRES_MAX_CONNECTIONS: ${POSTGRES_MAX_CONNECTIONS:-8}
POSTGRES_CONNECT_TIMEOUT: 500ms
POSTGRES_QUERY_TIMEOUT: 2s
REDIS_HOST: redis
REDIS_PORT: 6379
REDIS_DB: 0
REDIS_USERNAME: default
REDIS_PASSWORD: ${REDIS_PASSWORD:?Run scripts/bootstrap.sh}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
JWT_ACCESS_TOKEN_LIFETIME: 15m
JWT_PRIVATE_KEY_PATH: /run/certs/private_key.pem
JWT_PUBLIC_KEY_PATH: /run/certs/public_key.pem
S3_ENDPOINT: http://s3:9000
S3_REGION: us-east-1
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
UPLOAD_TIMEOUT: ${UPLOAD_TIMEOUT:-120s}
RECONCILE_GRACE_PERIOD: ${RECONCILE_GRACE_PERIOD:-1h}
GOMEMLIMIT: 384MiB
networks: [default, storage]
volumes:
- ./secrets/lab5/private_key.pem:/run/certs/private_key.pem:ro
- ./secrets/lab5/public_key.pem:/run/certs/public_key.pem:ro
- ./secrets/lab5/s3_api_access:/run/secrets/s3_access:ro
- ./secrets/lab5/s3_api_secret:/run/secrets/s3_secret:ro
stop_grace_period: 10s
services:
api:
<<: *api
deploy:
replicas: ${API_REPLICAS:-2}
depends_on:
migrate:
condition: service_completed_successfully
s3-init:
condition: service_completed_successfully
migrate:
<<: *api
# The migration command uses only PostgreSQL: no signing keys or Redis credentials.
volumes: []
environment:
<<: *environment
REDIS_PASSWORD: ""
restart: "no"
command: [migrate]
cpus: 0.5
mem_limit: 128m
healthcheck:
disable: true
depends_on:
postgres:
condition: service_healthy
lb:
image: ${HAPROXY_IMAGE:-haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0}
restart: unless-stopped
cpus: 0.5
mem_limit: 128m
ports:
- "127.0.0.1:${HOST_PORT:-18085}:8080"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api:
condition: service_started
healthcheck:
test: [CMD, wget, -q, -O, /dev/null, http://127.0.0.1:8080/health/ready]
interval: 2s
timeout: 1s
retries: 5
stop_grace_period: 10s
postgres:
image: postgres:17.11-alpine3.23@sha256:05aa77262db9277fde6374bb2f901c9604b8a9373029e1a7993440c6aae48736
restart: unless-stopped
cpus: 2
mem_limit: 1g
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Run scripts/bootstrap.sh}
POSTGRES_DB: messenger
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: [CMD-SHELL, 'pg_isready -U messenger -d messenger']
interval: 2s
timeout: 1s
retries: 30
stop_grace_period: 30s
redis:
image: redis:8.2.11-alpine3.22@sha256:489a769e0a54dc245896132a15c72d2bc7296719954da99398f43a3877e5f8eb
restart: unless-stopped
cpus: 0.25
mem_limit: 128m
environment:
REDIS_PASSWORD: ${REDIS_PASSWORD:?Run scripts/bootstrap.sh}
command: [sh, -c, 'exec docker-entrypoint.sh redis-server --appendonly yes --maxmemory 64mb --maxmemory-policy allkeys-lru --requirepass "$$REDIS_PASSWORD"']
volumes:
- redis_data:/data
healthcheck:
test: [CMD-SHELL, 'REDISCLI_AUTH="$$REDIS_PASSWORD" redis-cli --no-auth-warning ping | grep -qx PONG']
interval: 2s
timeout: 1s
retries: 20
stop_grace_period: 10s
s3:
image: chrislusf/seaweedfs:4.52@sha256:57877e32bb90073b37dc109b438ba66e84fd5ed9ced5f5c04f56444ef243ce59
restart: unless-stopped
cpus: 1
mem_limit: 512m
networks: [storage]
command: [server, '-dir=/data', '-ip=s3', '-ip.bind=0.0.0.0', '-volume.max=4', '-master.volumeSizeLimitMB=128', '-filer', '-s3', '-s3.port=9000', '-s3.config=/etc/seaweedfs/s3.json']
volumes:
- s3_data:/data
- ./secrets/lab5/s3.json:/etc/seaweedfs/s3.json:ro
healthcheck:
test: [CMD, wget, -q, -O, /dev/null, http://127.0.0.1:9333/cluster/status]
interval: 2s
timeout: 1s
retries: 30
stop_grace_period: 30s
s3-init:
<<: *api
restart: "no"
cpus: 0.25
mem_limit: 128m
command: [storage, bootstrap]
volumes:
- ./secrets/lab5/s3_admin_access:/run/secrets/s3_access:ro
- ./secrets/lab5/s3_admin_secret:/run/secrets/s3_secret:ro
healthcheck:
disable: true
depends_on:
s3:
condition: service_healthy
operator:
<<: *api
profiles: [tools]
restart: "no"
command: [storage, reconcile]
volumes:
- ./secrets/lab5/s3_admin_access:/run/secrets/s3_access:ro
- ./secrets/lab5/s3_admin_secret:/run/secrets/s3_secret:ro
- ./tests/fixtures:/fixtures:ro
healthcheck:
disable: true
depends_on: {}
volumes:
postgres_data:
redis_data:
s3_data:
networks:
storage:
internal: true
+39
View File
@@ -0,0 +1,39 @@
global
maxconn 4096
stats socket /tmp/haproxy.sock mode 600 level admin
stats socket ipv4@127.0.0.1:9999 level admin
defaults
mode http
timeout connect 500ms
timeout client 125s
timeout server 125s
timeout check 500ms
retries 0
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 2
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold obsolete 1s
hold nx 1s
frontend public
bind :8080
http-request deny deny_status 404 if { path_beg /internal }
default_backend api
backend api
balance roundrobin
http-reuse always
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
server-template replica 1-4 api:8080 check inter 1s fall 2 rise 1 resolvers docker init-addr none resolve-prefer ipv4
listen statistics
bind :8404
stats enable
stats uri /stats
+25
View File
@@ -0,0 +1,25 @@
#!/usr/bin/env python3
"""Generate local synthetic storage credentials without rotating existing keys."""
import json
import os
from pathlib import Path
import secrets
root=Path(__file__).resolve().parents[1]/'secrets'/'lab5'
root.mkdir(parents=True,exist_ok=True)
for name in ('s3_admin_access','s3_admin_secret','s3_api_access','s3_api_secret'):
p=root/name
if not p.exists():
p.write_text(secrets.token_hex(24)+'\n')
p.chmod(0o444) # Non-root containers must read these local synthetic secrets.
bucket=os.environ.get('S3_BUCKET','messenger-attachments')
identities=[]
for role,actions in [('admin',['Admin','Read','Write','List','Tagging']),('api',['Read:'+bucket,'Write:'+bucket,'List:'+bucket])]:
identities.append({'name':role,'credentials':[{'accessKey':(root/('s3_'+role+'_access')).read_text().strip(),'secretKey':(root/('s3_'+role+'_secret')).read_text().strip()}],'actions':actions})
p=root/'s3.json'
content=json.dumps({'identities':identities})+'\n'
if not p.exists() or p.read_text()!=content:
if p.exists(): p.chmod(0o600)
p.write_text(content)
p.chmod(0o444)
print('Local storage credentials ready; existing keys preserved.')
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
umask 077
mkdir -p secrets/lab5
if [ ! -f .env.lab5 ]; then
{ printf 'POSTGRES_PASSWORD='; openssl rand -hex 24
printf 'REDIS_PASSWORD='; openssl rand -hex 24
printf 'HOST_PORT=18085\nAPI_REPLICAS=2\n'
} > .env.lab5
fi
if [ ! -f secrets/lab5/private_key.pem ]; then
openssl genrsa -out secrets/lab5/private_key.pem 2048 2>/dev/null
fi
if [ ! -f secrets/lab5/public_key.pem ]; then
openssl rsa -in secrets/lab5/private_key.pem -pubout -out secrets/lab5/public_key.pem 2>/dev/null
fi
# Only synthetic stand keys, readable by the non-root application inside containers.
chmod 755 secrets secrets/lab5
chmod 444 secrets/lab5/*.pem
printf '%s\n' 'Local lab5 settings and synthetic keys ready; existing files preserved.'
python3 scripts/bootstrap-storage.py
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec docker compose --env-file .env.lab5 "$@"
+17
View File
@@ -0,0 +1,17 @@
#!/usr/bin/env python3
"""Convert a temporary generation view to the oapi-codegen 3.0 subset.
Runtime handlers enforce anyOf and required fields; normative contract is untouched.
"""
import json
from pathlib import Path
s=json.loads(Path('contracts/openapi.json').read_text())
for schema in s['components']['schemas'].values():
schema.pop('anyOf',None)
for prop in schema.get('properties',{}).values():
if prop.get('type')==['string','null']:
prop.update(type='string',nullable=True)
# Preserve pointers so handlers can distinguish missing fields from empty values.
for name,field in [('CreateUser','password'),('CreateMessage','text')]:
s['components']['schemas'][name]['properties'][field]['x-go-type-skip-optional-pointer']=False
s['components']['schemas'][name]['required'].remove(field)
print(json.dumps(s))
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
./scripts/compose.sh stop api lb
./scripts/compose.sh restart postgres redis s3
./scripts/compose.sh run --rm -T s3-init
./scripts/compose.sh up -d --wait --wait-timeout 90 api lb
+45
View File
@@ -0,0 +1,45 @@
#!/usr/bin/env python3
"""Drain and replace API processes individually, retaining other container IDs."""
import json,os,subprocess,time
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
def run(args,input=None):
p=subprocess.run(args,cwd=ROOT,input=input,text=True,capture_output=True,timeout=100)
if p.returncode:raise RuntimeError(p.stderr.strip()[:300])
return p.stdout.strip()
def runtime(lb,cmd):return run(['docker','exec','-i',lb,'nc','-w','1','127.0.0.1','9999'],cmd+'\n')
def ids():return run(['./scripts/compose.sh','ps','-q','api']).split()
def states(lb):
lines=runtime(lb,'show servers state').splitlines();head=lines[1].lstrip('# ').split()
return [dict(zip(head,l.split())) for l in lines[2:] if l.strip()]
def main():
initial=ids()
if len(initial)<2:raise SystemExit('rolling update requires at least two running API replicas')
lb=run(['./scripts/compose.sh','ps','-q','lb'])
for old in initial:
info=json.loads(run(['docker','inspect',old]))[0]
ip=next(iter(info['NetworkSettings']['Networks'].values()))['IPAddress']
backend=next(s['srv_name'] for s in states(lb) if s['srv_addr']==ip and s['be_name']=='api')
runtime(lb,f'set server api/{backend} state drain')
try:
deadline=time.monotonic()+10
while True:
# Existing transactions get a chance to finish before SIGTERM.
import csv,io
raw=run(['docker','exec',lb,'wget','-qO-','http://127.0.0.1:8404/stats;csv'])
row=next(r for r in csv.DictReader(io.StringIO(raw)) if r['# pxname']=='api' and r['svname']==backend)
if int(row['scur'])==0:break
if time.monotonic()>deadline:raise RuntimeError('backend did not drain')
time.sleep(.1)
before=set(ids());run(['docker','stop','--time','8',old]);run(['docker','rm',old])
run(['./scripts/compose.sh','up','-d','--no-deps','--no-recreate','--scale',f'api={len(initial)}','api'])
after=set(ids())
if not (before-{old}).issubset(after):raise RuntimeError('another replica was replaced unexpectedly')
new=(after-before).pop();deadline=time.monotonic()+60
while run(['docker','inspect','--format','{{.State.Health.Status}}',new])!='healthy':
if time.monotonic()>deadline:raise RuntimeError('replacement failed readiness')
time.sleep(.5)
print(json.dumps({'old_container':old,'new_container':new,'name':info['Name'],'drained_backend':backend}),flush=True)
finally:runtime(lb,f'set server api/{backend} state ready')
time.sleep(3) # allow DNS refresh and a successful active readiness check
if __name__=='__main__':main()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec python3 scripts/rolling-update.py
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?missing target alias}"
for id in $(./scripts/compose.sh ps -q api); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
case "$TARGET_INSTANCE_ID" in
"$hostname"-*)
current=$(docker exec "$id" wget -T 2 -qO- http://127.0.0.1:8080/internal/metrics | python3 -c 'import json,sys; print(json.load(sys.stdin)["instance_id"])')
[ "$current" = "$TARGET_INSTANCE_ID" ] || { printf '%s\n' 'Target process was already replaced' >&2; exit 1; }
docker stop --time 8 "$id" >/dev/null
exit 0 ;;
esac
done
printf '%s\n' 'Target does not match a running lab5 API container' >&2
exit 1
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p bin
(cd service && GOOS=linux GOARCH=$(docker info --format '{{.Architecture}}' | sed 's/aarch64/arm64/;s/x86_64/amd64/') CGO_ENABLED=0 go test -c -o ../bin/storage.test ./internal/adapter/repository/storage)
database="lab5_atomic_$(date +%s)_$$"
./scripts/compose.sh exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -c "CREATE DATABASE $database" >/dev/null
trap './scripts/compose.sh exec -T postgres psql -U messenger -d messenger -c "DROP DATABASE IF EXISTS $database WITH (FORCE)" >/dev/null' EXIT
id=$(./scripts/compose.sh ps -q api | head -n 1)
docker cp bin/storage.test "$id:/tmp/storage.test" >/dev/null
docker exec -e "TEST_DATABASE_NAME=$database" "$id" /tmp/storage.test -test.v
+150
View File
@@ -0,0 +1,150 @@
package main
import (
"context"
"fmt"
"log/slog"
"os"
"os/signal"
"syscall"
"time"
"encoding/json"
"gitea.privcloud.tech/mtusi2026/internal/adapter/controller/http"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/cache/outside"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/storage"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/cache"
"gitea.privcloud.tech/mtusi2026/internal/pkg/encrypting"
"gitea.privcloud.tech/mtusi2026/internal/pkg/migrator"
"gitea.privcloud.tech/mtusi2026/internal/pkg/objectstore"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/middleware"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/attachment"
"gitea.privcloud.tech/mtusi2026/internal/service/auth"
"gitea.privcloud.tech/mtusi2026/internal/service/chat"
"gitea.privcloud.tech/mtusi2026/internal/service/user"
"github.com/google/uuid"
stdhttp "net/http"
)
func main() {
time.Local = time.UTC
if err := run(); err != nil {
slog.Error("application stopped", "error", err)
os.Exit(1)
}
}
func run() error {
cfg, err := config.New()
if err != nil {
return fmt.Errorf("load server config: %w", err)
}
if len(os.Args) > 1 && os.Args[1] == "migrate" {
cfg.Postgres.RunMigrations = true
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
return migrator.New(cfg).Start(ctx)
}
attachmentConfig, err := config.LoadAttachment()
if err != nil {
return err
}
if len(os.Args) > 1 && os.Args[1] == "storage" {
return runStorage(cfg, attachmentConfig, os.Args[2:])
}
// API processes never run migrations; the one-shot migrator owns schema changes.
cfg.Postgres.RunMigrations = false
var level slog.Level
if err := level.UnmarshalText([]byte(cfg.Application.LogLevel)); err != nil {
return err
}
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: level})))
hostname, _ := os.Hostname()
instanceID := hostname + "-" + uuid.NewString()
slog.Info("instance_started", "instance_id", instanceID)
pgx := postgres.New(cfg.Postgres)
rx := cache.New(cfg)
postgresMigrator := migrator.New(cfg)
defer pgx.Close()
defer rx.Close()
tm := txmanager.New(pgx)
provider := jwtprovider.New(cfg)
encryptor := encrypting.New()
chatsRepo := storage.NewChatsRepo(pgx)
messageRepo := storage.NewMessagesRepo(pgx)
refreshTokensRepo := storage.NewRefreshTokensRepo(pgx)
userRepo := storage.NewUsersRepo(pgx)
chatCache := outside.NewChatCache(rx)
authSvc := auth.New(provider, tm, encryptor, userRepo, refreshTokensRepo)
userSvc := user.New(encryptor, userRepo)
chatSvc := chat.New(tm, chatsRepo, messageRepo, chatCache)
objectStore := objectstore.New(attachmentConfig)
attachmentSvc := attachment.New(&storage.AttachmentsRepo{Pool: pgx}, objectStore, attachmentConfig, chatSvc)
httpRouter := router.New(
middleware.NewAuthMiddleware(authSvc),
middleware.Instance(instanceID),
middleware.RequestIDMiddleware(),
middleware.LoggingMiddleware(),
middleware.RequestTimeout(cfg.Postgres.QueryTimeout, attachmentConfig.Timeout),
)
httpRouter.Get("/internal/metrics", func(w stdhttp.ResponseWriter, r *stdhttp.Request) {
stat := pgx.Stat()
_ = json.NewEncoder(w).Encode(map[string]any{"instance_id": instanceID, "acquire_count": stat.AcquireCount(), "acquire_duration_ns": stat.AcquireDuration().Nanoseconds(), "empty_acquire_count": stat.EmptyAcquireCount(), "acquired_conns": stat.AcquiredConns(), "total_conns": stat.TotalConns(), "max_conns": stat.MaxConns()})
})
server := http.New(cfg, httpRouter)
requestValidator := validator.NewValidatorImpl()
registerRoutes(
http.NewAuthHandler(httpRouter, authSvc),
http.NewHealthHandler(httpRouter, server, pgx, objectStore),
http.NewChatHandler(httpRouter, provider, requestValidator, chatSvc),
http.NewUserHandler(httpRouter, provider, requestValidator, userSvc),
http.NewAttachmentHandler(httpRouter, provider, attachmentSvc),
)
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
if err = postgresMigrator.Start(ctx); err != nil {
return fmt.Errorf("start postgres migrator: %w", err)
}
if err = server.Start(ctx); err != nil {
return fmt.Errorf("start HTTP server: %w", err)
}
if err = rx.Start(ctx); err != nil {
slog.Warn("redis unavailable at startup; continuing without cache", "error", err)
}
slog.Info("HTTP server started", "address", cfg.Server.BindAddress())
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.Server.ShutdownTimeout)
defer cancel()
if err = server.Stop(shutdownCtx); err != nil {
return fmt.Errorf("stop HTTP server: %w", err)
}
if err = postgresMigrator.Close(shutdownCtx); err != nil {
return fmt.Errorf("close postgres migrator: %w", err)
}
if err = rx.Close(); err != nil {
return fmt.Errorf("close redis: %w", err)
}
pgx.Close()
return nil
}
func registerRoutes(handlers ...http.Handler) {
for _, handler := range handlers {
handler.RegisterRoutes()
}
}
+175
View File
@@ -0,0 +1,175 @@
package main
import (
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"log/slog"
"net/http"
"os"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/smithy-go"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/storage"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/objectstore"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
"gitea.privcloud.tech/mtusi2026/internal/service/attachment"
)
func runStorage(cfg *config.Config, c *config.Attachment, args []string) error {
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})))
if len(args) == 0 {
return fmt.Errorf("storage command required")
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer cancel()
store := objectstore.New(c)
if args[0] == "bootstrap" {
var err error
for i := 0; i < 60; i++ {
_, err = store.Client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: &c.Bucket})
var api smithy.APIError
if err == nil || (errors.As(err, &api) && (api.ErrorCode() == "BucketAlreadyOwnedByYou" || api.ErrorCode() == "BucketAlreadyExists")) {
if store.Ping(ctx) == nil {
// HEAD alone can succeed before the restarted master/volume write path.
// This constant key is outside the application's immutable originals prefix.
key := "bootstrap/write-check"
if store.Put(ctx, key, "application/octet-stream", strings.NewReader("ready"), 5) == nil && store.Delete(ctx, key) == nil {
return json.NewEncoder(os.Stdout).Encode(map[string]any{"bucket_ready": true, "write_checked": true})
}
}
}
time.Sleep(time.Second)
}
return fmt.Errorf("storage bootstrap failed: %w", err)
}
if args[0] == "private-check" {
// Unsigned requests must reach the S3 server and receive an auth failure,
// rather than passing because a network error hid a public object.
fs := flag.NewFlagSet("private-check", flag.ContinueOnError)
key := fs.String("key", "", "known object key")
if e := fs.Parse(args[1:]); e != nil {
return e
}
client := http.Client{Timeout: 5 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
resp, e := client.Get(c.Endpoint + "/" + c.Bucket + "/" + *key)
if e != nil {
return e
}
defer resp.Body.Close()
if resp.StatusCode != 401 && resp.StatusCode != 403 {
return fmt.Errorf("unsigned GET returned %d", resp.StatusCode)
}
_, e = store.Client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: new("forbidden-" + uuid.NewString())})
var api smithy.APIError
if !errors.As(e, &api) || api.ErrorCode() != "AccessDenied" {
return fmt.Errorf("API key bucket creation was not denied")
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"anonymous_status": resp.StatusCode, "api_create_bucket_denied": true})
}
if args[0] == "object-check" {
fs := flag.NewFlagSet("object-check", flag.ContinueOnError)
key := fs.String("key", "", "synthetic object key")
if e := fs.Parse(args[1:]); e != nil {
return e
}
head, e := store.Head(ctx, *key)
if objectstore.Missing(e) {
return json.NewEncoder(os.Stdout).Encode(map[string]any{"exists": false})
}
if e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"exists": true, "last_modified": head.LastModified, "size_bytes": head.ContentLength})
}
pool := postgres.New(cfg.Postgres)
defer pool.Close()
svc := attachment.New(&storage.AttachmentsRepo{Pool: pool}, store, c, nil)
switch args[0] {
case "reconcile":
fs := flag.NewFlagSet("reconcile", flag.ContinueOnError)
apply := fs.Bool("apply", false, "apply safe changes")
if e := fs.Parse(args[1:]); e != nil {
return e
}
result, e := svc.Reconcile(ctx, *apply)
_ = json.NewEncoder(os.Stdout).Encode(result)
return e
case "restore":
fs := flag.NewFlagSet("restore", flag.ContinueOnError)
id := fs.String("id", "", "attachment id")
source := fs.String("source", "", "original file")
if e := fs.Parse(args[1:]); e != nil {
return e
}
uid, e := uuid.Parse(*id)
if e != nil {
return e
}
if e = svc.Restore(ctx, uid, *source); e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"restored": uid})
case "seed":
fs := flag.NewFlagSet("seed", flag.ContinueOnError)
count := fs.Int("count", 1, "synthetic orphan count")
keyOverride := fs.String("key", "", "explicit key for a single synthetic object")
if e := fs.Parse(args[1:]); e != nil {
return e
}
if *count < 1 || *count > 10000 {
return fmt.Errorf("count must be 1..10000")
}
keys := []string{}
for i := 0; i < *count; i++ {
key := attachment.Prefix + uuid.NewString()
if *keyOverride != "" {
if *count != 1 {
return fmt.Errorf("explicit key requires count=1")
}
key = *keyOverride
}
if e := store.Put(ctx, key, "image/png", strings.NewReader("synthetic-orphan"), 16); e != nil {
return e
}
if *count == 1 {
keys = append(keys, key)
}
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"seeded": *count, "keys": keys})
case "remove-object":
fs := flag.NewFlagSet("remove-object", flag.ContinueOnError)
id := fs.String("id", "", "synthetic attachment id")
if e := fs.Parse(args[1:]); e != nil {
return e
}
uid, e := uuid.Parse(*id)
if e != nil {
return e
}
a, e := svc.Repo.Get(ctx, uid)
if e != nil {
return e
}
conn, unlock, e := svc.Repo.Lock(ctx, a.Key)
_ = conn
if e != nil {
return e
}
defer unlock()
if e = store.Delete(ctx, a.Key); e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"removed_object": uid})
default:
return fmt.Errorf("unknown storage command")
}
}
+260
View File
@@ -0,0 +1,260 @@
// Command benchmark generates paced lab5 traffic through the public load balancer.
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"math"
"net/http"
"os"
"slices"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/google/uuid"
)
type client struct {
base, token string
http *http.Client
}
func (c *client) call(method, path string, body any, key string) (map[string]any, int, error) {
var data io.Reader
if body != nil {
b, e := json.Marshal(body)
if e != nil {
return nil, 0, e
}
data = bytes.NewReader(b)
}
req, e := http.NewRequest(method, c.base+path, data)
if e != nil {
return nil, 0, e
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if c.token != "" {
req.Header.Set("Authorization", "Bearer "+c.token)
}
if key != "" {
req.Header.Set("Idempotency-Key", key)
}
// net/http otherwise treats Idempotency-Key + GetBody as permission to retry POST.
if method == http.MethodPost {
req.GetBody = nil
}
resp, e := c.http.Do(req)
if e != nil {
return nil, 0, e
}
defer resp.Body.Close()
b, e := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
if e != nil {
return nil, resp.StatusCode, e
}
if resp.StatusCode != 200 && resp.StatusCode != 201 {
return nil, resp.StatusCode, fmt.Errorf("HTTP %d", resp.StatusCode)
}
var out map[string]any
e = json.Unmarshal(b, &out)
return out, resp.StatusCode, e
}
func (c *client) setup(seed int) (string, error) {
username := "bench_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:20]
password := "Synthetic-benchmark-123"
user, _, e := c.call("POST", "/api/v1/users", map[string]string{"username": username, "display_name": "Benchmark", "password": password}, "")
if e != nil {
return "", e
}
req, _ := http.NewRequest("POST", c.base+"/api/v1/auth/sessions", nil)
req.SetBasicAuth(username, password)
resp, e := c.http.Do(req)
if e != nil {
return "", e
}
var session struct {
Token string `json:"token"`
}
e = json.NewDecoder(resp.Body).Decode(&session)
resp.Body.Close()
if e != nil || resp.StatusCode != 201 || session.Token == "" {
return "", fmt.Errorf("login status %d: %v", resp.StatusCode, e)
}
c.token = session.Token
chat, _, e := c.call("POST", "/api/v1/chats", map[string]any{"title": "Benchmark", "member_ids": []any{user["id"]}}, "")
if e != nil {
return "", e
}
path := "/api/v1/chats/" + chat["id"].(string) + "/messages"
// Bounded concurrent setup is excluded from the measured interval.
var group sync.WaitGroup
slots := make(chan struct{}, 8)
errs := make(chan error, seed)
for i := range seed {
slots <- struct{}{}
group.Go(func() {
defer func() { <-slots }()
_, _, e := c.call("POST", path, map[string]string{"text": fmt.Sprintf("seed-%d", i)}, uuid.NewString())
if e != nil {
errs <- e
}
})
}
group.Wait()
close(errs)
for e := range errs {
if e != nil {
return "", e
}
}
return path, nil
}
type result struct {
MeasurementUnix float64 `json:"measurement_started_unix"`
Label string `json:"label"`
TargetRate int `json:"target_rps"`
Duration float64 `json:"duration_seconds"`
Elapsed float64 `json:"elapsed_including_drain_seconds"`
Scheduled int `json:"scheduled"`
Dropped int `json:"generator_dropped"`
Success int `json:"successful_requests"`
Errors int `json:"failed_requests"`
ReadSuccess int `json:"read_success"`
WriteSuccess int `json:"write_success"`
SuccessfulRPS float64 `json:"successful_rps"`
ErrorRatio float64 `json:"error_ratio_including_drops"`
Latency map[string]float64 `json:"successful_latency_ms"`
Statuses map[int]int `json:"statuses"`
PeakInFlight int64 `json:"peak_in_flight"`
Note string `json:"note"`
}
func phase(c *client, path string, rate int, duration time.Duration, maxInFlight int, label string) result {
out := result{Label: label, TargetRate: rate, Duration: duration.Seconds(), Statuses: map[int]int{}, Latency: map[string]float64{}, Note: "Paced open-loop, 10ms dispatch batches; 90% first-page GET, 10% POST; no POST retries. Percentiles of successes include scheduler delay; failures and capacity drops reported separately. RPS denominator includes drain."}
start := time.Now()
out.MeasurementUnix = float64(start.UnixNano()) / 1e9
end := start.Add(duration)
slots := make(chan struct{}, maxInFlight)
var group sync.WaitGroup
var mu sync.Mutex
var active atomic.Int64
var peak atomic.Int64
latencies := make([]float64, 0, rate*int(duration.Seconds()))
index := 0
for tick := 0; ; tick++ {
now := time.Now()
if !now.Before(end) {
break
}
target := start.Add(time.Duration(tick) * 10 * time.Millisecond)
if target.After(now) {
time.Sleep(time.Until(target))
}
until := min(int(time.Since(start).Seconds()*float64(rate))+1, int(duration.Seconds()*float64(rate)))
for index < until {
i := index
index++
out.Scheduled++
scheduled := start.Add(time.Duration(float64(i) / float64(rate) * float64(time.Second)))
select {
case slots <- struct{}{}:
group.Go(func() {
n := active.Add(1)
for old := peak.Load(); n > old; old = peak.Load() {
if peak.CompareAndSwap(old, n) {
break
}
}
defer func() { active.Add(-1); <-slots }()
method, p := "GET", path+"?limit=50"
var body any
key := ""
if i%10 == 0 {
method = "POST"
p = path
key = uuid.NewString()
body = map[string]string{"text": key}
}
_, status, err := c.call(method, p, body, key)
latency := float64(time.Since(scheduled).Microseconds()) / 1000
mu.Lock()
defer mu.Unlock()
out.Statuses[status]++
if err != nil {
out.Errors++
} else {
out.Success++
if method == "GET" {
out.ReadSuccess++
} else {
out.WriteSuccess++
}
latencies = append(latencies, max(0, latency))
}
})
default:
out.Dropped++
}
}
}
group.Wait()
out.Elapsed = time.Since(start).Seconds()
out.PeakInFlight = peak.Load()
out.SuccessfulRPS = float64(out.Success) / out.Elapsed
if out.Scheduled > 0 {
out.ErrorRatio = float64(out.Errors+out.Dropped) / float64(out.Scheduled)
}
slices.Sort(latencies)
for name, p := range map[string]float64{"p50": .5, "p95": .95, "p99": .99} {
if len(latencies) > 0 {
out.Latency[name] = latencies[max(0, int(math.Ceil(p*float64(len(latencies))))-1)]
}
}
return out
}
func main() {
base := flag.String("base-url", "http://localhost:18085", "public LB URL")
rate := flag.Int("rate", 100, "scheduled requests per second")
duration := flag.Duration("duration", 30*time.Second, "measured time")
warmup := flag.Duration("warmup", 5*time.Second, "warmup excluded from results")
seed := flag.Int("seed", 1000, "initial messages")
maxFlight := flag.Int("max-in-flight", 256, "bounded in-flight limit")
label := flag.String("label", "manual", "case label")
output := flag.String("output", "", "JSON destination")
flag.Parse()
if *rate < 1 || *rate > 100000 || *duration <= 0 || *warmup < 0 || *maxFlight < 1 || *seed < 0 {
fmt.Fprintln(os.Stderr, "invalid benchmark settings")
os.Exit(2)
}
c := &client{base: *base, http: &http.Client{Timeout: 2 * time.Second, Transport: &http.Transport{MaxIdleConns: 512, MaxIdleConnsPerHost: 512, MaxConnsPerHost: *maxFlight, IdleConnTimeout: 60 * time.Second}}}
path, e := c.setup(*seed)
if e != nil {
fmt.Fprintln(os.Stderr, "setup:", e)
os.Exit(1)
}
if *warmup > 0 {
phase(c, path, *rate, *warmup, *maxFlight, "warmup")
}
row := phase(c, path, *rate, *duration, *maxFlight, *label)
b, e := json.MarshalIndent(row, "", " ")
if e != nil {
panic(e)
}
if *output != "" {
if e = os.WriteFile(*output, append(b, '\n'), 0644); e != nil {
panic(e)
}
}
fmt.Println(string(b))
if row.Success == 0 {
os.Exit(1)
}
}
+42
View File
@@ -0,0 +1,42 @@
package main
import (
"io"
"net/http"
"net/http/httptest"
"sync/atomic"
"testing"
"time"
)
func TestLostPostResponseIsNotRetried(t *testing.T) {
var posts atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodGet {
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{}`))
return
}
posts.Add(1)
_, _ = io.Copy(io.Discard, r.Body)
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
t.Error(err)
return
}
_ = conn.Close()
}))
defer server.Close()
transport := &http.Transport{MaxIdleConnsPerHost: 1}
defer transport.CloseIdleConnections()
c := &client{base: server.URL, http: &http.Client{Timeout: time.Second, Transport: transport}}
if _, _, err := c.call(http.MethodGet, "/warm", nil, ""); err != nil {
t.Fatal(err)
}
if _, _, err := c.call(http.MethodPost, "/message", map[string]string{"text": "uncertain result"}, "same-key"); err == nil {
t.Fatal("lost response must be reported as an error")
}
if posts.Load() != 1 {
t.Fatalf("transport sent %d POSTs, want exactly 1", posts.Load())
}
}
+66
View File
@@ -0,0 +1,66 @@
module gitea.privcloud.tech/mtusi2026
go 1.27.0
require (
github.com/aws/aws-sdk-go-v2 v1.47.8
github.com/aws/aws-sdk-go-v2/credentials v1.20.16
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.9
github.com/aws/smithy-go v1.28.8
github.com/go-chi/chi/v5 v5.5.0
github.com/go-playground/validator/v10 v10.30.5
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/uuid v1.6.0
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6
github.com/jackc/pgx/v5 v5.11.0
github.com/jackc/tern/v2 v2.4.3
github.com/mcosta74/pgx-slog v0.4.1
github.com/oapi-codegen/runtime v1.4.2
github.com/redis/go-redis/v9 v9.23.0
github.com/spf13/viper v1.21.0
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0
go.uber.org/multierr v1.11.0
golang.org/x/crypto v0.57.0
golang.org/x/sync v0.23.0
google.golang.org/grpc v1.85.0
)
require (
dario.cat/mergo v1.0.2 // indirect
github.com/Masterminds/goutils v1.1.1 // indirect
github.com/Masterminds/semver/v3 v3.5.0 // indirect
github.com/Masterminds/sprig/v3 v3.3.0 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.26 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.11 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.11 // indirect
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.11 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.24 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.12 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.11 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.11 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/fsnotify/fsnotify v1.9.0 // indirect
github.com/gabriel-vasile/mimetype v1.4.15 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
github.com/huandu/xstrings v1.5.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/leodido/go-urn v1.5.0 // indirect
github.com/mitchellh/copystructure v1.2.0 // indirect
github.com/mitchellh/reflectwalk v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1 // indirect
github.com/sagikazarmark/locafero v0.11.0 // indirect
github.com/shopspring/decimal v1.4.0 // indirect
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
github.com/spf13/afero v1.15.0 // indirect
github.com/spf13/cast v1.10.0 // indirect
github.com/spf13/pflag v1.0.10 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
)
+147
View File
@@ -0,0 +1,147 @@
dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI=
github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU=
github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=
github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
github.com/Masterminds/sprig/v3 v3.3.0 h1:mQh0Yrg1XPo6vjYXgtf5OtijNAKJRNcTdOOGZe3tPhs=
github.com/Masterminds/sprig/v3 v3.3.0/go.mod h1:Zy1iXRYNqNLUolqCpL4uhk6SHUMAOSCzdgBfDb35Lz0=
github.com/aws/aws-sdk-go-v2 v1.47.8 h1:fuClo7Un+Bi0EDTnSIPWxVEoJcze+wkGzNA4Vo3jRcQ=
github.com/aws/aws-sdk-go-v2 v1.47.8/go.mod h1:I8lFSH4MGrZiw2m7miCrRYHsgpC1+HW8uiVGOiPYPcw=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.26 h1:SJNA4XaM8Z09adeTHf/vME93jzl44lJV70pSawIBXac=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.26/go.mod h1:l0ME5pd2QytH8UZzETcrt90x9Bm+3TyBVeWfVEcZ82c=
github.com/aws/aws-sdk-go-v2/credentials v1.20.16 h1:cqRWTY4fcctJGqZedMC1Khu4h2VsgRODUOIZwn39n3Y=
github.com/aws/aws-sdk-go-v2/credentials v1.20.16/go.mod h1:x8JgCOAnbnEVQOLVX6lOtsyTrG2EHgiRNqzku9jiVxA=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.11 h1:LTxHSJ/rwTFfaXqi5mlKKHJOW+shFB+HQ7NrCa4OQ48=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.11/go.mod h1:GF0bVKZVQX4UeUtPmTuWZj3gw0eRCdkVhW0xFnSRLmU=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.11 h1:DGUM0yztI3Zz5kePulT/mMP/gVZFGTTISUiCcqSQtT0=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.11/go.mod h1:kbcdJgN9cgSzZlUqsMveDl9IfexJqOzCihXjQXTNaPk=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.11 h1:kOHCwgWFyfrz9GqnJct8knQw7Apyl3xHH+OGnome77s=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.11/go.mod h1:854cZkT2fdkdrzQklD49uzxkZnajXoelpVNgT/yk4J0=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.24 h1:jGzHjc2jDx08Rji1JTBtMxuXUDG7muTEw+ExYXqFzPg=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.24/go.mod h1:uJt75pK2cEyY80F5C+DK9YkCkJWsMkJViHxLYZRHl8Y=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.12 h1:hfO8FblXX93ZKHXSCqCjehwul1EtNJa9G8iFSOiJ+6w=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.12/go.mod h1:r8Eypc7ZRNdS7BsaLBUUdcXIEuKE6cVHZJ29u+IGaIc=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.11 h1:PO7Tx443ecMI00nIxDrT99DVcbeMBQ6BUtJlDMRnY24=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.11/go.mod h1:n/9RixikO12YvNomZLP8k4TgUSoEkT1W23QIrpFAPvw=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.11 h1:jNP7wZylDeSJhjc1nmjZBuG5deotp3cEYIfMazmzp+Y=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.11/go.mod h1:1US+8JBnF0xNm6GE6wM5u5ugFwSZpkd2686gMuql5tI=
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.9 h1:MLHGyNy4melTyk9e63s+9QgLKCHPDJrP+1NfJhtU1g4=
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.9/go.mod h1:zfUkiNK2JiYlR1/SnU8aJ8Gj1nMFLkPZ69rVLv6jWPo=
github.com/aws/smithy-go v1.28.8 h1:aEmdAq7gVCoGCnvf1NnELlu3I6D/nhqrC321FyFiQkQ=
github.com/aws/smithy-go v1.28.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
github.com/gabriel-vasile/mimetype v1.4.15 h1:05iP/CYtZ/w455R/KZM6rZ5ieAdh99UPtd+d3YzLmaI=
github.com/gabriel-vasile/mimetype v1.4.15/go.mod h1:azpTcoLcDZRNgFou5j+APrqQx9HqVPWa6ijYQIIVswQ=
github.com/go-chi/chi/v5 v5.5.0 h1:xdKQ1dJmVJsmgahrXSKhUx8NyVPzpwdlyrrQFpMPJgg=
github.com/go-chi/chi/v5 v5.5.0/go.mod h1:d1IG7GtKPSjPyBP365PH8sAGVHk3qfB/IhjFNRH1wWM=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.5 h1:YyCXvVShZbs2Sm3Mb53eNOlhRXctSOzW5QJAouCTZL4=
github.com/go-playground/validator/v10 v10.30.5/go.mod h1:wEqiaov48pXX1kjhc3Da8y0M0Dtg/BK7gurFBLgwFrQ=
github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
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/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI=
github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 h1:D/V0gu4zQ3cL2WKeVNVM4r2gLxGGf6McLwgXzRTo2RQ=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds=
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-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/jackc/tern/v2 v2.4.3 h1:g293d3OZgW7OFEhsYXgEv0C21jea2boNr0VR4K5I7OY=
github.com/jackc/tern/v2 v2.4.3/go.mod h1:rMpMuRYcff5wWLptoTSO1qcDxJ4OodysvK17i2SVBys=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/leodido/go-urn v1.5.0 h1:pLqT2kq1zpHW/1D18QMjMpdtX7cekxqtJJjg5ANyWw0=
github.com/leodido/go-urn v1.5.0/go.mod h1:9BORnCDhdPBJNDEX+w1bJisa8yOKYi116VeO96s4ifE=
github.com/mcosta74/pgx-slog v0.4.1 h1:Rt25l/jE5tu1ioqPDrqY17Kv6REdsM0L9WCT+hFw1rw=
github.com/mcosta74/pgx-slog v0.4.1/go.mod h1:BCpubkiENkWQ8MvZ4a9LJgWuBzC5UpWoJmQ1/SOlv+M=
github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
github.com/oapi-codegen/runtime v1.4.2 h1:GMxFVYLzoYLua+/KvzgSphkyK1lLTReQI9Vf4hvATKE=
github.com/oapi-codegen/runtime v1.4.2/go.mod h1:GwV7hC2hviaMzj+ITfHVRESK5J2W/GefVwIND/bMGvU=
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1 h1:gIZQQ2+wbsdQGWLPDSdJFptR25tBCjSC0KbSIQZ1rgE=
github.com/pelletier/go-toml/v2 v2.4.3-0.20260624044523-35f78d5908f1/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
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.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0 h1:EhPtK0mgrgaTMXpegE69hvoSOVC1Ahk8+QJ9B8b+OdU=
github.com/vgarvardt/pgx-google-uuid/v5 v5.6.0/go.mod h1:5LtFrNEkgzxHvXPO9eOvcXsSn9/KeKYgx9kjeI2oXQI=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260817212433-ac3dfec99bb1 h1:utmqiUzZAEINbLmRyAt1QjVkMyLQ+lvIwCpLaB1rZfw=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260817212433-ac3dfec99bb1/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
google.golang.org/grpc v1.85.0 h1:BPBCfuVRQ1qvBhKDOq9uvQllMvO59rKsYhXpp7Dd8vw=
google.golang.org/grpc v1.85.0/go.mod h1:0rQrOD58yjal/0EaVbGBANindixsCZNQPDV3VKtaKuQ=
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
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=
@@ -0,0 +1 @@
package http
@@ -0,0 +1,91 @@
package http
import (
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/service/attachment"
"io"
"net/http"
"strconv"
"strings"
)
type AttachmentHandler struct {
router router.Router
provider jwtprovider.Provider
svc *attachment.Service
}
func NewAttachmentHandler(r router.Router, p jwtprovider.Provider, s *attachment.Service) Handler {
return &AttachmentHandler{r, p, s}
}
func (h *AttachmentHandler) RegisterRoutes() {
h.router.Private("POST", "/api/v1/chats/{chat_id}/attachments", h.Upload)
h.router.Private("GET", "/api/v1/attachments/{attachment_id}", h.Get)
h.router.Private("GET", "/api/v1/attachments/{attachment_id}/content", h.Get)
}
func (h *AttachmentHandler) Upload(w http.ResponseWriter, r *http.Request) {
user, e := framework.ParseToken(r, h.provider)
if e != nil {
framework.JSONError(r.Context(), w, e)
return
}
id, e := framework.ParseIDFromPathParam(r.Context(), w, r, "chat_id")
if e != nil {
return
}
values := r.URL.Query()["filename"]
if len(values) != 1 {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "expected one filename"))
return
}
a, e := h.svc.Upload(w, r, user.UserID, id, values[0])
if e != nil {
if apperr.CodeFromError(e) == apperr.CodeTooManyRequests {
w.Header().Set("Retry-After", "1")
}
framework.JSONError(r.Context(), w, e)
return
}
framework.JSONResponse(w, http.StatusCreated, a)
}
func (h *AttachmentHandler) Get(w http.ResponseWriter, r *http.Request) {
user, e := framework.ParseToken(r, h.provider)
if e != nil {
framework.JSONError(r.Context(), w, e)
return
}
id, e := framework.ParseIDFromPathParam(r.Context(), w, r, "attachment_id")
if e != nil {
return
}
a, e := h.svc.Get(r.Context(), user.UserID, id)
if e != nil {
framework.JSONError(r.Context(), w, e)
return
}
if !strings.HasSuffix(r.URL.Path, "/content") {
framework.JSONResponse(w, 200, a.Public)
return
}
if v := r.URL.Query().Get("variant"); v != "" && v != "original" {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid variant"))
return
}
obj, e := h.svc.Store.Get(r.Context(), a.Key)
if e != nil {
framework.JSONError(r.Context(), w, attachment.Unavailable())
return
}
defer obj.Body.Close()
w.Header().Set("Content-Type", string(a.Public.ContentType))
w.Header().Set("Content-Length", strconv.Itoa(a.Public.SizeBytes))
w.Header().Set("X-Content-Type-Options", "nosniff")
// Once streaming has started a transport failure terminates the response; no JSON
// error can be appended to an image. Content-Length exposes incomplete downloads.
if _, e = io.Copy(w, obj.Body); e != nil {
panic(http.ErrAbortHandler)
}
}
@@ -0,0 +1,88 @@
package http
import (
"net/http"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/service/auth"
)
type AuthHandler struct {
router router.Router
auth auth.API
}
func NewAuthHandler(r router.Router, api auth.API) Handler {
return &AuthHandler{
router: r,
auth: api,
}
}
func (h *AuthHandler) RegisterRoutes() {
h.router.Public(http.MethodPost, "/api/v1/auth/sessions", h.Login)
h.router.Private(http.MethodDelete, "/api/v1/auth/sessions/current", h.Logout)
}
func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
username, password, ok := r.BasicAuth()
if !ok || username == "" || password == "" {
w.Header().Set(
"WWW-Authenticate",
`Basic realm="messenger", charset="UTF-8"`,
)
framework.JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "invalid credentials"))
return
}
resp, err := h.auth.Login(ctx, dto.Login{
Username: username,
Password: password,
})
if err != nil {
if apperr.HTTPStatusFromError(err) == http.StatusUnauthorized {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Session{
ExpiresAt: resp.ExpiresAt,
Token: resp.Tokens.RefreshToken.Payload,
TokenType: resp.TokenType,
User: contracts.User{
CreatedAt: resp.User.CreatedAt,
DisplayName: resp.User.DisplayName,
Id: resp.User.ID,
Username: resp.User.Username,
},
})
}
func (h *AuthHandler) Logout(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
token, exists := framework.Token(r)
if !exists {
framework.JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "missing token in header"))
return
}
err := h.auth.Logout(ctx, dto.RefreshToken{
Payload: token,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusNoContent, nil)
}
@@ -0,0 +1,287 @@
package http
import (
"bytes"
"encoding/json"
"net/http"
"regexp"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/chat"
)
var messageKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
type ChatHandler struct {
router router.Router
provider jwtprovider.Provider
validator *validator.ValidatorImpl
chat chat.API
}
func NewChatHandler(r router.Router, provider jwtprovider.Provider, v *validator.ValidatorImpl, api chat.API) Handler {
return &ChatHandler{
router: r,
provider: provider,
validator: v,
chat: api,
}
}
func (h *ChatHandler) RegisterRoutes() {
h.router.Private(http.MethodPost, "/api/v1/chats", h.Create)
h.router.Private(http.MethodGet, "/api/v1/chats", h.Get)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}", h.GetByID)
h.router.Private(http.MethodPost, "/api/v1/chats/{chat_id}/messages", h.SendMessage)
h.router.Private(http.MethodGet, "/api/v1/chats/{chat_id}/messages", h.GetMessages)
}
func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
var req contracts.CreateChat
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if userData.UserID == uuid.Nil ||
!validText(req.Title, 100) ||
len(req.MemberIds) < 1 ||
len(req.MemberIds) > 100 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid chat fields"))
return
}
resp, err := h.chat.CreateChat(ctx, dto.CreateChat{
CreatorID: userData.UserID,
Title: req.Title,
MemberIDs: req.MemberIds,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Chat{
Id: resp.ID,
Title: resp.Title,
MemberIds: resp.MemberIDs,
CreatedAt: resp.CreatedAt,
})
}
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
if userData.UserID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user id"))
return
}
if afterID != nil && *afterID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return
}
page, err := h.chat.ListForMember(ctx, dto.ChatFilters{
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Chat, 0, len(page.Items))
for _, item := range page.Items {
items = append(items, contracts.Chat{
CreatedAt: item.CreatedAt,
Id: item.ID,
MemberIds: item.MemberIDs,
Title: item.Title,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.ChatPage{
Items: items,
NextCursor: cursorString(page.NextCursorID),
})
}
func (h *ChatHandler) GetByID(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
resp, err := h.chat.GetForMember(ctx, dto.ChatMember{
UserID: userData.UserID,
ChatID: chatID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusOK, contracts.Chat{
CreatedAt: resp.CreatedAt,
Id: resp.ID,
MemberIds: resp.MemberIDs,
Title: resp.Title,
})
}
func (h *ChatHandler) SendMessage(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
keyValues := r.Header.Values("Idempotency-Key")
if len(keyValues) != 1 || !messageKeyPattern.MatchString(keyValues[0]) {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid idempotency key"))
return
}
var req struct {
Text *string `json:"text"`
AttachmentIDs json.RawMessage `json:"attachment_ids"`
}
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
if req.Text == nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "text is required"))
return
}
ids := []uuid.UUID{}
if len(req.AttachmentIDs) > 0 {
if bytes.Equal(bytes.TrimSpace(req.AttachmentIDs), []byte("null")) || json.Unmarshal(req.AttachmentIDs, &ids) != nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid attachment_ids"))
return
}
}
message, err := h.chat.CreateMessage(ctx, dto.CreateMessage{
IdempotencyKey: keyValues[0],
ChatID: chatID,
SenderID: userData.UserID,
Text: *req.Text,
AttachmentIDs: ids,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
AttachmentIds: message.AttachmentIDs,
})
}
func (h *ChatHandler) GetMessages(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
chatID, err := framework.ParseIDFromPathParam(ctx, w, r, "chat_id")
if err != nil {
return
}
limit, afterID, ok := framework.PageParams(w, r)
if !ok {
return
}
page, err := h.chat.ListForChat(ctx, dto.MessageFilters{
ChatID: chatID,
UserID: userData.UserID,
Limit: limit,
AfterID: afterID,
})
if err != nil {
framework.JSONError(ctx, w, err)
return
}
items := make([]contracts.Message, 0, len(page.Items))
for _, message := range page.Items {
items = append(items, contracts.Message{
Id: message.ID,
ChatId: message.ChatID,
SenderId: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
AttachmentIds: message.AttachmentIDs,
})
}
framework.JSONResponse(w, http.StatusOK, contracts.MessagePage{Items: items, NextCursor: cursorString(page.NextCursorID)})
}
func cursorString(id *uuid.UUID) *string {
if id == nil {
return nil
}
value := id.String()
return &value
}
func validText(value string, maxLength int) bool {
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxLength
}
@@ -0,0 +1,102 @@
package http
import (
"context"
"errors"
"log/slog"
"net"
"net/http"
"sync/atomic"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
)
type Server interface {
ShouldBeRunning() bool
Ready() bool
Start(ctx context.Context) error
Stop(ctx context.Context) error
}
type server struct {
server http.Server
cfg *config.Server
ready atomic.Bool
}
func New(cfg *config.Config, router router.Router) Server {
s := server{
server: http.Server{
Addr: cfg.Server.BindAddress(),
Handler: router,
ReadTimeout: cfg.Server.ReadTimeout,
WriteTimeout: cfg.Server.WriteTimeout,
IdleTimeout: cfg.Server.IdleTimeout,
},
cfg: cfg.Server,
ready: atomic.Bool{},
}
if err := s.validate(); err != nil {
panic(err)
}
return &s
}
func (s *server) Start(_ context.Context) error {
if !s.ShouldBeRunning() {
slog.Info("server should not be running: skip starting")
return nil
}
listener, err := net.Listen("tcp", s.server.Addr)
if err != nil {
return err
}
s.ready.Store(true)
go func() {
defer s.ready.Store(false)
if err := s.server.Serve(listener); err != nil &&
!errors.Is(err, http.ErrServerClosed) {
slog.Error("rest server failed", "error", err)
}
}()
return nil
}
func (s *server) Stop(ctx context.Context) error {
if !s.ShouldBeRunning() {
slog.Info("server should not be running: skip stopping")
return nil
}
slog.Info("shutting down rest server...", "address", s.server.Addr)
s.ready.Store(false)
if err := s.server.Shutdown(ctx); err != nil {
slog.Error("rest server shutdown failed", "error", err)
_ = s.server.Close()
return err
}
slog.Info("rest server shutdown successfully")
return nil
}
func (s *server) ShouldBeRunning() bool {
return s.cfg.Enabled
}
func (s *server) Ready() bool {
return s.ready.Load()
}
func (s *server) validate() error {
if s.cfg == nil {
slog.Error("failed to validate server: provided nil config")
return errors.New("failed to validate server: provided nil config")
}
slog.Info("server successfully validated")
return nil
}
@@ -0,0 +1,5 @@
package http
type Handler interface {
RegisterRoutes()
}
@@ -0,0 +1,60 @@
package http
import (
"context"
"net/http"
"time"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
)
type databasePinger interface{ Ping(context.Context) error }
type HealthHandler struct {
router router.Router
server Server
database databasePinger
storage []databasePinger
}
func NewHealthHandler(r router.Router, server Server, database databasePinger, storage ...databasePinger) Handler {
return &HealthHandler{
router: r,
server: server,
database: database,
storage: storage,
}
}
func (h *HealthHandler) RegisterRoutes() {
h.router.Public(http.MethodGet, "/health/ready", h.Ready)
h.router.Public(http.MethodGet, "/health/live", h.Live)
}
func (h *HealthHandler) Live(w http.ResponseWriter, _ *http.Request) {
framework.JSONResponse(w, http.StatusOK, contracts.Health{Status: contracts.Ok})
}
func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) {
if !h.server.Ready() {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeUnavailable, "server is not ready"))
return
}
ctx, cancel := context.WithTimeout(r.Context(), 200*time.Millisecond)
defer cancel()
if err := h.database.Ping(ctx); err != nil {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeUnavailable, "database unavailable"))
return
}
for _, dependency := range h.storage {
if err := dependency.Ping(ctx); err != nil {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeUnavailable, "storage unavailable"))
return
}
}
framework.JSONResponse(w, http.StatusOK, contracts.Health{Status: contracts.Ok})
}
@@ -0,0 +1 @@
package http
@@ -0,0 +1,113 @@
package http
import (
"net/http"
"regexp"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/router"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
"gitea.privcloud.tech/mtusi2026/internal/service/user"
)
type UserHandler struct {
router router.Router
provider jwtprovider.Provider
validator *validator.ValidatorImpl
user user.API
}
func NewUserHandler(r router.Router, provider jwtprovider.Provider, v *validator.ValidatorImpl, api user.API) Handler {
return &UserHandler{
router: r,
provider: provider,
validator: v,
user: api,
}
}
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
func (h *UserHandler) RegisterRoutes() {
h.router.Public(http.MethodPost, "/api/v1/users", h.Create)
h.router.Private(http.MethodGet, "/api/v1/users/me", h.GetMe)
}
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
var req contracts.CreateUser
if !framework.Decode(w, r, &req) || !framework.Validate(w, r, h.validator, &req) {
return
}
toCreate := dto.CreateUser{
Username: req.Username,
DisplayName: req.DisplayName,
}
if req.Password != nil {
toCreate.Password = *req.Password
}
if !usernamePattern.MatchString(req.Username) || !utf8.ValidString(req.DisplayName) ||
strings.TrimSpace(req.DisplayName) == "" || utf8.RuneCountInString(req.DisplayName) > 100 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user fields"))
return
}
passwordLen := utf8.RuneCountInString(toCreate.Password)
if !utf8.ValidString(toCreate.Password) || strings.TrimSpace(toCreate.Password) == "" || passwordLen < 12 || passwordLen > 128 {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid password"))
return
}
resp, err := h.user.Create(ctx, toCreate)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusCreated, contracts.User{
CreatedAt: resp.CreatedAt,
DisplayName: resp.DisplayName,
Id: resp.ID,
Username: resp.Username,
})
}
func (h *UserHandler) GetMe(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
userData, err := framework.ParseToken(r, h.provider)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
if userData.UserID == uuid.Nil {
framework.JSONError(ctx, w, apperr.New(apperr.CodeBadRequest, "invalid user id"))
return
}
resp, err := h.user.GetByID(ctx, userData.UserID)
if err != nil {
framework.JSONError(ctx, w, err)
return
}
framework.JSONResponse(w, http.StatusOK, contracts.User{
CreatedAt: resp.CreatedAt,
DisplayName: resp.DisplayName,
Id: resp.ID,
Username: resp.Username,
})
}
@@ -0,0 +1,78 @@
package outside
import (
"context"
"encoding/json"
"fmt"
"time"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/cache"
)
const (
// chatRedisKey equals "chat:{chat_id}" path
chatRedisKey = "chat:%s"
)
type ChatCache struct {
client *cache.Client
}
func NewChatCache(client *cache.Client) *ChatCache {
return &ChatCache{
client: client,
}
}
type chat struct {
ID uuid.UUID `json:"id"`
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
func (r *ChatCache) Create(ctx context.Context, req dto.Chat) error {
data, err := json.Marshal(chat{
ID: req.ID,
Title: req.Title,
MemberIDs: req.MemberIDs,
CreatedAt: req.CreatedAt,
})
if err != nil {
return apperr.Wrap(err, apperr.CodeInternal, "failed to marshal chat cache")
}
ctx, cancel := context.WithTimeout(ctx, cache.OperationTimeout)
defer cancel()
err = r.client.Set(ctx, fmt.Sprintf(chatRedisKey, req.ID), data, 0).Err()
if err != nil {
return apperr.WrapRedis(err, "failed to create chat cache")
}
return nil
}
func (r *ChatCache) Get(ctx context.Context, chatID uuid.UUID) (*dto.Chat, error) {
ctx, cancel := context.WithTimeout(ctx, cache.OperationTimeout)
defer cancel()
data, err := r.client.Get(ctx, fmt.Sprintf(chatRedisKey, chatID.String())).Bytes()
if err != nil {
return nil, apperr.WrapRedis(err, "failed to read chat cache")
}
var item chat
if err = json.Unmarshal(data, &item); err != nil {
return nil, apperr.Wrap(err, apperr.CodeInternal, "failed to unmarshal chat cache")
}
return &dto.Chat{
ID: item.ID,
Title: item.Title,
MemberIDs: item.MemberIDs,
CreatedAt: item.CreatedAt,
}, nil
}
@@ -0,0 +1,34 @@
package storage
import (
"context"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
)
func (r *AttachmentsRepo) Page(ctx context.Context, after uuid.UUID) ([]*AttachmentRecord, error) {
rows, e := r.Pool.Query(ctx, "SELECT "+AttachmentColumns+" FROM attachments WHERE id>$1 ORDER BY id LIMIT 100", after)
if e != nil {
return nil, apperr.WrapPostgres(e, "scan failed")
}
defer rows.Close()
out := make([]*AttachmentRecord, 0, 100)
for rows.Next() {
a, e := ScanAttachment(rows)
if e != nil {
return nil, e
}
out = append(out, a)
}
return out, rows.Err()
}
func (r *AttachmentsRepo) Exists(ctx context.Context, c *pgxpool.Conn, key string) (bool, error) {
var found bool
e := c.QueryRow(ctx, "SELECT EXISTS(SELECT 1 FROM attachments WHERE object_key=$1)", key).Scan(&found)
return found, e
}
func (r *AttachmentsRepo) MarkMissing(ctx context.Context, c *pgxpool.Conn, id uuid.UUID, missing bool) (bool, error) {
tag, e := c.Exec(ctx, "UPDATE attachments SET integrity_missing=$2,updated_at=clock_timestamp() WHERE id=$1 AND integrity_missing<>$2", id, missing)
return tag.RowsAffected() == 1, e
}
@@ -0,0 +1,71 @@
package storage
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
)
type AttachmentRecord struct {
Public contracts.Attachment
Key string
Missing bool
}
type AttachmentsRepo struct{ Pool *pgxpool.Pool }
const AttachmentColumns = "id,chat_id,owner_id,filename,content_type,size_bytes,sha256,created_at,updated_at,object_key,integrity_missing"
func ScanAttachment(row pgx.Row) (*AttachmentRecord, error) {
a := new(AttachmentRecord)
p := &a.Public
if err := row.Scan(&p.Id, &p.ChatId, &p.OwnerId, &p.Filename, &p.ContentType, &p.SizeBytes, &p.Sha256, &p.CreatedAt, &p.UpdatedAt, &a.Key, &a.Missing); err != nil {
return nil, apperr.WrapPostgres(err, "attachment unavailable")
}
p.Status = "ready"
p.Variants = []contracts.Variant{}
return a, nil
}
func (r *AttachmentsRepo) Get(ctx context.Context, id uuid.UUID) (*AttachmentRecord, error) {
return ScanAttachment(r.Pool.QueryRow(ctx, "SELECT "+AttachmentColumns+" FROM attachments WHERE id=$1", id))
}
func (r *AttachmentsRepo) Save(ctx context.Context, conn *pgxpool.Conn, a *AttachmentRecord) error {
p := a.Public
_, e := conn.Exec(ctx, `INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,created_at,updated_at,object_key) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)`, p.Id, p.ChatId, p.OwnerId, p.Filename, p.ContentType, p.SizeBytes, p.Sha256, p.CreatedAt, p.UpdatedAt, a.Key)
if e != nil {
return apperr.WrapPostgres(e, "failed to save attachment")
}
return nil
}
// Session locks span S3 work and the database commit. A lost connection releases
// the lock; the mandatory grace period also exceeds the maximum upload lifetime.
func (r *AttachmentsRepo) Lock(ctx context.Context, key string) (*pgxpool.Conn, func(), error) {
c, e := r.Pool.Acquire(ctx)
if e != nil {
return nil, nil, apperr.WrapPostgres(e, "database unavailable")
}
if _, e = c.Exec(ctx, "SELECT pg_advisory_lock(hashtextextended($1, 42))", key); e != nil {
// The server may have acquired the session lock before cancellation was
// observed by the client. Never return that uncertain session to the pool.
clean, cancel := context.WithTimeout(context.Background(), 2*time.Second)
_ = c.Conn().Close(clean)
cancel()
c.Release()
return nil, nil, apperr.WrapPostgres(e, "lock unavailable")
}
return c, func() {
// Close rather than return a possibly locked session when unlock fails.
clean, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if _, e := c.Exec(clean, "SELECT pg_advisory_unlock(hashtextextended($1, 42))", key); e != nil {
_ = c.Conn().Close(clean)
}
c.Release()
}, nil
}
@@ -0,0 +1,91 @@
package storage
import (
"context"
"errors"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
)
type ChatsRepo struct {
pool *pgxpool.Pool
}
func NewChatsRepo(pool *pgxpool.Pool) *ChatsRepo {
return &ChatsRepo{pool: pool}
}
func (r *ChatsRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.Chat) error {
const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`
if _, err := tx.Exec(ctx, insertChat, req.ID, req.Title, req.CreatedAt); err != nil {
return apperr.WrapPostgres(err, "failed to create chat")
}
const insertMembers = `INSERT INTO chat_members (chat_id, user_id)
SELECT $1, user_id FROM unnest($2::uuid[]) AS members(user_id)`
if _, err := tx.Exec(ctx, insertMembers, req.ID, req.MemberIDs); err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok &&
pgErr.Code == pgerrcode.ForeignKeyViolation && pgErr.ConstraintName == "chat_members_user_fk" {
return apperr.Wrap(err, apperr.CodeBadRequest, "unknown chat member")
}
return apperr.WrapPostgres(err, "failed to create chat members")
}
return nil
}
func (r *ChatsRepo) GetForMember(ctx context.Context, req dto.ChatMember) (*dto.Chat, error) {
const query = `SELECT c.id, c.title, c.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.user_id)
FROM chats c
WHERE c.id = $1
AND EXISTS (SELECT 1 FROM chat_members access WHERE access.chat_id = c.id AND access.user_id = $2)`
return scanChat(r.pool.QueryRow(ctx, query, req.ChatID, req.UserID))
}
func (r *ChatsRepo) ListForMember(ctx context.Context, userID uuid.UUID, page dto.PageQuery) ([]dto.Chat, error) {
query := `WITH page AS MATERIALIZED (
SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members access ON access.chat_id = c.id
WHERE access.user_id = $1`
args := []any{userID, page.Limit}
if page.After != nil {
query += ` AND (c.created_at, c.id) > ($3, $4)`
args = append(args, page.After.CreatedAt, page.After.ID)
}
query += ` ORDER BY c.created_at, c.id LIMIT $2
)
SELECT p.id, p.title, p.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = p.id ORDER BY m.user_id)
FROM page p ORDER BY p.created_at, p.id`
rows, err := r.pool.Query(ctx, query, args...)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to list chats")
}
defer rows.Close()
chats := make([]dto.Chat, 0)
for rows.Next() {
chat, err := scanChat(rows)
if err != nil {
return nil, err
}
chats = append(chats, *chat)
}
if err = rows.Err(); err != nil {
return nil, apperr.WrapPostgres(err, "failed to list chats")
}
return chats, nil
}
func scanChat(row pgx.Row) (*dto.Chat, error) {
var chat dto.Chat
if err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get chat")
}
return &chat, nil
}
@@ -0,0 +1,303 @@
package storage
import (
"context"
"crypto/sha256"
"errors"
"fmt"
"os"
"strings"
"testing"
"time"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/migrator"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
chatsvc "gitea.privcloud.tech/mtusi2026/internal/service/chat"
"github.com/google/uuid"
)
// The explicit runner supplies a newly created database; never alter the API database.
func TestIdempotencyTransactionAndExpiry(t *testing.T) {
database := os.Getenv("TEST_DATABASE_NAME")
if database == "" {
t.Skip("run make test-storage for an isolated PostgreSQL database")
}
if database == os.Getenv("POSTGRES_DATABASE") {
t.Fatal("test database must differ from application database")
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
cfg, err := config.New()
if err != nil {
t.Fatal(err)
}
cfg.Postgres.Database = database
cfg.Postgres.RunMigrations = true
if err = migrator.New(cfg).Start(ctx); err != nil {
t.Fatal(err)
}
pool := postgres.New(cfg.Postgres)
defer pool.Close()
repo := NewMessagesRepo(pool)
user, chat := uuid.New(), uuid.New()
if _, err = pool.Exec(ctx, `INSERT INTO users(id,name,username,password_hash) VALUES($1,'Synthetic','atomic_test','unused')`, user); err != nil {
t.Fatal(err)
}
if _, err = pool.Exec(ctx, `INSERT INTO chats(id,title) VALUES($1,'Atomic test')`, chat); err != nil {
t.Fatal(err)
}
if _, err = pool.Exec(ctx, `INSERT INTO chat_members(chat_id,user_id) VALUES($1,$2)`, chat, user); err != nil {
t.Fatal(err)
}
req := dto.CreateMessage{ChatID: chat, SenderID: user, Text: "atomic", IdempotencyKey: "atomic-key"}
tx, err := pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = repo.CreateIdempotentTx(ctx, tx, req); err != nil {
t.Fatal(err)
}
if err = tx.Rollback(ctx); err != nil {
t.Fatal(err)
}
var messages, keys int
if err = pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM messages),(SELECT count(*) FROM message_idempotency)`).Scan(&messages, &keys); err != nil {
t.Fatal(err)
}
if messages != 0 || keys != 0 {
t.Fatalf("rollback left %d messages, %d keys", messages, keys)
}
tx, err = pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
first, err := repo.CreateIdempotentTx(ctx, tx, req)
if err != nil {
t.Fatal(err)
}
if err = tx.Commit(ctx); err != nil {
t.Fatal(err)
}
// Expire the test record only: no shortened production TTL and no wall-clock wait.
if _, err = pool.Exec(ctx, `UPDATE message_idempotency SET expires_at=clock_timestamp()-interval '1 second' WHERE user_id=$1`, user); err != nil {
t.Fatal(err)
}
req.Text = "new after expiry"
tx, err = pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
second, err := repo.CreateIdempotentTx(ctx, tx, req)
if err != nil {
t.Fatal(err)
}
if err = tx.Commit(ctx); err != nil {
t.Fatal(err)
}
if first.ID == second.ID {
t.Fatal("expired key replayed old message")
}
if err = pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM messages),(SELECT count(*) FROM message_idempotency)`).Scan(&messages, &keys); err != nil {
t.Fatal(err)
}
if messages != 2 || keys != 1 {
t.Fatalf("expiry left %d messages, %d keys; want 2,1", messages, keys)
}
if _, err = pool.Exec(ctx, `CREATE FUNCTION reject_test_key() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.key='failure-key' THEN RAISE EXCEPTION 'synthetic failure'; END IF; RETURN NEW; END $$; CREATE TRIGGER reject_test_key BEFORE INSERT ON message_idempotency FOR EACH ROW EXECUTE FUNCTION reject_test_key()`); err != nil {
t.Fatal(err)
}
req.IdempotencyKey = "failure-key"
tx, err = pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = repo.CreateIdempotentTx(ctx, tx, req); err == nil {
t.Fatal("expected injected failure")
}
if err = tx.Rollback(ctx); err != nil {
t.Fatal(err)
}
if err = pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM messages),(SELECT count(*) FROM message_idempotency)`).Scan(&messages, &keys); err != nil {
t.Fatal(err)
}
if messages != 2 || keys != 1 {
t.Fatal("failed result persisted a side effect")
}
if _, err = pool.Exec(ctx, `DROP TRIGGER reject_test_key ON message_idempotency; DROP FUNCTION reject_test_key()`); err != nil {
t.Fatal(err)
}
tx, err = pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = repo.CreateIdempotentTx(ctx, tx, req); err != nil {
t.Fatal("transient failure was cached", err)
}
if err = tx.Commit(ctx); err != nil {
t.Fatal(err)
}
t.Run("service owns message content rules", func(t *testing.T) {
svc := chatsvc.New(txmanager.New(pool), NewChatsRepo(pool), repo, uncachedChats{})
own, foreign, missing := uuid.New(), uuid.New(), uuid.New()
otherChat := uuid.New()
if _, err := pool.Exec(ctx, `INSERT INTO chats(id,title) VALUES($1,'Other chat');`, otherChat); err != nil {
t.Fatal(err)
}
if _, err := pool.Exec(ctx, `INSERT INTO chat_members(chat_id,user_id) VALUES($1,$2)`, otherChat, user); err != nil {
t.Fatal(err)
}
for _, fixture := range []struct {
id, chat uuid.UUID
missing bool
}{{own, chat, false}, {foreign, otherChat, false}, {missing, chat, true}} {
if _, err := pool.Exec(ctx, `INSERT INTO attachments(id,chat_id,owner_id,filename,object_key,content_type,size_bytes,sha256,integrity_missing,created_at,updated_at) VALUES($1,$2,$3,'test.png',$4,'image/png',1,$5,$6,now(),now())`, fixture.id, fixture.chat, user, "originals/"+fixture.id.String(), strings.Repeat("a", 64), fixture.missing); err != nil {
t.Fatal(err)
}
}
counts := func() string {
t.Helper()
var messages, links, keys int
if err := pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM messages),(SELECT count(*) FROM message_attachments),(SELECT count(*) FROM message_idempotency)`).Scan(&messages, &links, &keys); err != nil {
t.Fatal(err)
}
return fmt.Sprintf("%d/%d/%d", messages, links, keys)
}
for _, tc := range []struct {
name, text string
ids []uuid.UUID
code apperr.Code
}{
{"empty", "", nil, apperr.CodeBadRequest},
{"whitespace", " \t\n\u2003", nil, apperr.CodeBadRequest},
{"invalid UTF8", string([]byte{0xff}), nil, apperr.CodeBadRequest},
{"nul", "\x00", nil, apperr.CodeBadRequest},
{"too long", strings.Repeat("я", 4001), nil, apperr.CodeBadRequest},
{"duplicate", "", []uuid.UUID{own, own}, apperr.CodeBadRequest},
{"too many", "text", make([]uuid.UUID, 11), apperr.CodeBadRequest},
{"nil id", "", []uuid.UUID{uuid.Nil}, apperr.CodeBadRequest},
{"unknown", "", []uuid.UUID{uuid.New()}, apperr.CodeNotFound},
{"foreign chat", "", []uuid.UUID{foreign}, apperr.CodeNotFound},
{"missing object", "", []uuid.UUID{missing}, apperr.CodeUnavailable},
} {
t.Run(tc.name, func(t *testing.T) {
before := counts()
_, err := svc.CreateMessage(ctx, dto.CreateMessage{ChatID: chat, SenderID: user, IdempotencyKey: uuid.NewString(), Text: tc.text, AttachmentIDs: tc.ids})
if err == nil || apperr.CodeFromError(err) != tc.code {
t.Fatalf("got %v, want code %v", err, tc.code)
}
if after := counts(); after != before {
t.Fatalf("rejected message changed counts: %s -> %s", before, after)
}
})
}
for _, text := range []string{"", " \t\u2003"} {
request := dto.CreateMessage{ChatID: chat, SenderID: user, IdempotencyKey: uuid.NewString(), Text: text, AttachmentIDs: []uuid.UUID{own}}
first, err := svc.CreateMessage(ctx, request)
if err != nil {
t.Fatal(err)
}
replay, err := svc.CreateMessage(ctx, request)
if err != nil || replay.ID != first.ID || len(replay.AttachmentIDs) != 1 || replay.AttachmentIDs[0] != own {
t.Fatalf("attachment replay failed: %v, %v", replay, err)
}
page, err := svc.ListForChat(ctx, dto.MessageFilters{UserID: user, ChatID: chat})
if err != nil {
t.Fatal(err)
}
found := false
for _, msg := range page.Items {
if msg.ID == first.ID {
found = len(msg.AttachmentIDs) == 1 && msg.AttachmentIDs[0] == own
}
}
if !found {
t.Fatal("history lost attachment")
}
request.AttachmentIDs = []uuid.UUID{foreign}
if _, err = svc.CreateMessage(ctx, request); apperr.CodeFromError(err) != apperr.CodeNotFound {
t.Fatalf("foreign replay: %v", err)
}
}
// Preserve legacy hashes written before the attachment migration.
legacy := dto.CreateMessage{ChatID: chat, SenderID: user, IdempotencyKey: uuid.NewString(), Text: "legacy"}
first, err := svc.CreateMessage(ctx, legacy)
if err != nil {
t.Fatal(err)
}
hash := sha256.Sum256([]byte(legacy.Text))
if _, err = pool.Exec(ctx, `UPDATE message_idempotency SET request_hash=$1,hash_version=1 WHERE key=$2`, hash[:], legacy.IdempotencyKey); err != nil {
t.Fatal(err)
}
replay, err := svc.CreateMessage(ctx, legacy)
if err != nil || replay.ID != first.ID {
t.Fatalf("legacy replay failed: %v", err)
}
legacy.AttachmentIDs = []uuid.UUID{own}
if _, err = svc.CreateMessage(ctx, legacy); apperr.CodeFromError(err) != apperr.CodeConflict {
t.Fatalf("legacy hash ignored new attachment: %v", err)
}
textOnly := dto.CreateMessage{ChatID: chat, SenderID: user, IdempotencyKey: uuid.NewString(), Text: "text only"}
first, err = svc.CreateMessage(ctx, textOnly)
if err != nil {
t.Fatal(err)
}
textOnly.AttachmentIDs = []uuid.UUID{}
replay, err = svc.CreateMessage(ctx, textOnly)
if err != nil || replay.ID != first.ID {
t.Fatalf("nil and empty attachment lists differ: %v", err)
}
// Force link failure using the relational FK and prove all preceding writes roll back.
before := counts()
tx, err := pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
_, err = repo.CreateIdempotentTx(ctx, tx, dto.CreateMessage{ChatID: chat, SenderID: user, IdempotencyKey: uuid.NewString(), Text: "link rollback", AttachmentIDs: []uuid.UUID{own, uuid.New()}})
if err == nil {
t.Fatal("expected missing attachment FK failure")
}
_ = tx.Rollback(ctx)
if after := counts(); after != before {
t.Fatalf("failed link changed counts: %s -> %s", before, after)
}
var triggers int
if err = pool.QueryRow(ctx, `SELECT count(*) FROM pg_trigger WHERE tgname='message_content'`).Scan(&triggers); err != nil || triggers != 0 {
t.Fatalf("message trigger remains: %d, %v", triggers, err)
}
})
t.Run("object lock cancellation does not leak a pooled lock", func(t *testing.T) {
attachments := &AttachmentsRepo{Pool: pool}
key := "originals/" + uuid.NewString()
_, unlock, err := attachments.Lock(ctx, key)
if err != nil {
t.Fatal(err)
}
waiting, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
_, _, err = attachments.Lock(waiting, key)
cancel()
unlock()
if err == nil {
t.Fatal("contending lock ignored deadline")
}
_, release, err := attachments.Lock(ctx, key)
if err != nil {
t.Fatalf("lock leaked after cancellation: %v", err)
}
release()
})
t.Log("rollback removed both side effect and key; expired key created one new message")
}
type uncachedChats struct{}
func (uncachedChats) Create(context.Context, dto.Chat) error { return nil }
func (uncachedChats) Get(context.Context, uuid.UUID) (*dto.Chat, error) {
return nil, errors.New("cache disabled for storage test")
}
@@ -0,0 +1,153 @@
package storage
import (
"bytes"
"context"
"crypto/sha256"
"encoding/json"
"errors"
"time"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
)
type MessagesRepo struct {
pool *pgxpool.Pool
}
func NewMessagesRepo(pool *pgxpool.Pool) *MessagesRepo {
return &MessagesRepo{pool: pool}
}
// CreateIdempotentTx serializes only requests sharing an idempotency scope.
// The transaction commits both the message and its replay record, or neither.
func (r *MessagesRepo) CreateIdempotentTx(ctx context.Context, tx pgx.Tx, req dto.CreateMessage) (*dto.Message, error) {
scope := req.SenderID.String() + ":POST:" + req.ChatID.String() + ":" + req.IdempotencyKey
if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock(hashtextextended($1, 0))`, scope); err != nil {
return nil, apperr.WrapPostgres(err, "failed to lock message key")
}
hash := messageHash(req)
var hashVersion int
var storedHash []byte
var messageID uuid.UUID
err := tx.QueryRow(ctx, `SELECT request_hash, message_id, hash_version FROM message_idempotency
WHERE user_id=$1 AND method='POST' AND chat_id=$2 AND key=$3 AND expires_at>clock_timestamp()`,
req.SenderID, req.ChatID, req.IdempotencyKey).Scan(&storedHash, &messageID, &hashVersion)
if err == nil {
if hashVersion == 1 && len(req.AttachmentIDs) == 0 {
hash = sha256.Sum256([]byte(req.Text))
} else if hashVersion != 2 {
return nil, apperr.New(apperr.CodeConflict, "idempotency key used with different content")
}
if !bytes.Equal(hash[:], storedHash) {
return nil, apperr.New(apperr.CodeConflict, "idempotency key used with different content")
}
return scanMessage(tx.QueryRow(ctx, `SELECT `+messageColumns+` FROM messages WHERE id=$1`, messageID))
}
if !errors.Is(err, pgx.ErrNoRows) {
return nil, apperr.WrapPostgres(err, "failed to read message key")
}
message := dto.Message{ID: uuid.New(), ChatID: req.ChatID, SenderID: req.SenderID, Text: req.Text, AttachmentIDs: append([]uuid.UUID{}, req.AttachmentIDs...), CreatedAt: time.Now().UTC().Truncate(time.Microsecond)}
if _, err = tx.Exec(ctx, `INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES($1,$2,$3,$4,$5)`,
message.ID, message.ChatID, message.SenderID, message.Text, message.CreatedAt); err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == pgerrcode.ForeignKeyViolation {
return nil, apperr.Wrap(err, apperr.CodeNotFound, "chat not found")
}
return nil, apperr.WrapPostgres(err, "failed to create message")
}
for position, attachmentID := range req.AttachmentIDs {
if _, err = tx.Exec(ctx, `INSERT INTO message_attachments(message_id,chat_id,attachment_id,position) VALUES($1,$2,$3,$4)`, message.ID, message.ChatID, attachmentID, position); err != nil {
return nil, apperr.WrapPostgres(err, "failed to link attachment")
}
}
if _, err = tx.Exec(ctx, `INSERT INTO message_idempotency(user_id,method,chat_id,key,request_hash,message_id,expires_at,hash_version)
VALUES($1,'POST',$2,$3,$4,$5,clock_timestamp()+interval '24 hours',2)
ON CONFLICT(user_id,method,chat_id,key) DO UPDATE SET request_hash=EXCLUDED.request_hash,
message_id=EXCLUDED.message_id,expires_at=EXCLUDED.expires_at,hash_version=EXCLUDED.hash_version`, req.SenderID, req.ChatID, req.IdempotencyKey, hash[:], message.ID); err != nil {
return nil, apperr.WrapPostgres(err, "failed to save message key")
}
return &message, nil
}
func (r *MessagesRepo) GetByIDForChat(ctx context.Context, chatID, messageID uuid.UUID) (*dto.Message, error) {
const query = `SELECT ` + messageColumns + ` FROM messages WHERE chat_id = $1 AND id = $2`
return scanMessage(r.pool.QueryRow(ctx, query, chatID, messageID))
}
func (r *MessagesRepo) ListForChat(ctx context.Context, chatID uuid.UUID, page dto.PageQuery) ([]dto.Message, error) {
query := `SELECT ` + messageColumns + ` FROM messages WHERE chat_id = $1`
args := []any{chatID, page.Limit}
if page.After != nil {
query += ` AND (created_at, id) > ($3, $4)`
args = append(args, page.After.CreatedAt, page.After.ID)
}
query += ` ORDER BY created_at, id LIMIT $2`
rows, err := r.pool.Query(ctx, query, args...)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to list messages")
}
defer rows.Close()
messages := make([]dto.Message, 0)
for rows.Next() {
message, err := scanMessage(rows)
if err != nil {
return nil, err
}
messages = append(messages, *message)
}
if err = rows.Err(); err != nil {
return nil, apperr.WrapPostgres(err, "failed to list messages")
}
return messages, nil
}
func scanMessage(row pgx.Row) (*dto.Message, error) {
var message dto.Message
if err := row.Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &message.CreatedAt, &message.AttachmentIDs); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get message")
}
return &message, nil
}
const messageColumns = `id, chat_id, sender_id, text, created_at,
ARRAY(SELECT attachment_id FROM message_attachments WHERE message_id=messages.id ORDER BY position)`
func messageHash(req dto.CreateMessage) [32]byte {
// Field order and a non-nil list define the canonical v2 representation.
canonical := struct {
Text string `json:"text"`
AttachmentIDs []uuid.UUID `json:"attachment_ids"`
}{req.Text, append([]uuid.UUID{}, req.AttachmentIDs...)}
encoded, _ := json.Marshal(canonical) // strings and UUIDs have no encoding failures.
return sha256.Sum256(encoded)
}
func (r *MessagesRepo) AttachmentsForMessageTx(ctx context.Context, tx pgx.Tx, ids []uuid.UUID) ([]dto.MessageAttachment, error) {
// Prevent a concurrent integrity update from invalidating the checked rows
// until the message and its links have committed together.
rows, err := tx.Query(ctx, `SELECT id, chat_id, integrity_missing FROM attachments WHERE id=ANY($1) ORDER BY id FOR SHARE`, ids)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to read attachments")
}
defer rows.Close()
result := make([]dto.MessageAttachment, 0, len(ids))
for rows.Next() {
var a dto.MessageAttachment
if err := rows.Scan(&a.ID, &a.ChatID, &a.Missing); err != nil {
return nil, apperr.WrapPostgres(err, "failed to read attachment")
}
result = append(result, a)
}
if err := rows.Err(); err != nil {
return nil, apperr.WrapPostgres(err, "failed to read attachments")
}
return result, nil
}
@@ -0,0 +1,193 @@
package storage
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
)
type RefreshTokensRepo struct {
pool *pgxpool.Pool
}
func NewRefreshTokensRepo(pool *pgxpool.Pool) *RefreshTokensRepo {
return &RefreshTokensRepo{
pool: pool,
}
}
func (r *RefreshTokensRepo) Create(ctx context.Context, req dto.StoredRefreshToken) error {
return r.create(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.StoredRefreshToken) error {
return r.create(ctx, tx, req)
}
func (r *RefreshTokensRepo) GetByID(ctx context.Context, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, r.pool, id, false)
}
func (r *RefreshTokensRepo) GetByIDTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, tx, id, false)
}
func (r *RefreshTokensRepo) GetByIDForUpdate(ctx context.Context, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, r.pool, id, true)
}
func (r *RefreshTokensRepo) GetByIDForUpdateTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.StoredRefreshToken, error) {
return r.getByID(ctx, tx, id, true)
}
func (r *RefreshTokensRepo) Revoke(ctx context.Context, req dto.RevokeRefreshToken) error {
return r.revoke(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) RevokeTx(ctx context.Context, tx pgx.Tx, req dto.RevokeRefreshToken) error {
return r.revoke(ctx, tx, req)
}
func (r *RefreshTokensRepo) RevokeAllByUserID(ctx context.Context, req dto.RevokeRefreshTokensByUserID) error {
return r.revokeAllByUserID(ctx, r.pool, req)
}
func (r *RefreshTokensRepo) RevokeAllByUserIDTx(ctx context.Context, tx pgx.Tx, req dto.RevokeRefreshTokensByUserID) error {
return r.revokeAllByUserID(ctx, tx, req)
}
func (r *RefreshTokensRepo) DeleteExpired(ctx context.Context) error {
const query = `
DELETE FROM refresh_tokens
WHERE expires_at < $1`
_, err := r.pool.Exec(ctx, query, time.Now())
if err != nil {
return apperr.WrapPostgres(err, "failed to delete expired refresh tokens")
}
return nil
}
func (r *RefreshTokensRepo) create(ctx context.Context, conn postgres.Conn, req dto.StoredRefreshToken) error {
const query = `INSERT INTO refresh_tokens (id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
created_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
ct, err := conn.Exec(
ctx,
query,
req.ID,
req.UserID,
req.TokenHash,
req.UserAgent,
req.IPAddress,
req.Role,
req.ExpiresAt,
req.CreatedAt,
)
if err != nil {
return apperr.WrapPostgres(err, "failed to create refresh token")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeAlreadyExists, "refresh token already exists")
}
return nil
}
func (r *RefreshTokensRepo) getByID(ctx context.Context, conn postgres.Conn, id uuid.UUID, lock bool) (*dto.StoredRefreshToken, error) {
const query = `SELECT id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
revoked_at,
created_at
FROM refresh_tokens
WHERE id = $1`
const queryLock = `SELECT id,
user_id,
token_hash,
user_agent,
ip_address,
role,
expires_at,
revoked_at,
created_at
FROM refresh_tokens
WHERE id = $1 FOR UPDATE`
use := query
if lock {
use = queryLock
}
var token dto.StoredRefreshToken
err := conn.QueryRow(ctx, use, id).Scan(
&token.ID,
&token.UserID,
&token.TokenHash,
&token.UserAgent,
&token.IPAddress,
&token.Role,
&token.ExpiresAt,
&token.RevokedAt,
&token.CreatedAt,
)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to get refresh by id")
}
return &token, nil
}
func (r *RefreshTokensRepo) revoke(ctx context.Context, conn postgres.Conn, req dto.RevokeRefreshToken) error {
const query = `
UPDATE refresh_tokens
SET revoked_at = $2
WHERE id = $1
AND revoked_at IS NULL`
ct, err := conn.Exec(ctx, query, req.ID, req.RevokedAt)
if err != nil {
return apperr.WrapPostgres(err, "failed to revoke refresh token")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeNotFound, "refresh token not found")
}
return nil
}
func (r *RefreshTokensRepo) revokeAllByUserID(ctx context.Context, conn postgres.Conn, req dto.RevokeRefreshTokensByUserID) error {
const query = `
UPDATE refresh_tokens
SET revoked_at = $2
WHERE user_id = $1
AND revoked_at IS NULL`
_, err := conn.Exec(ctx, query, req.UserID, req.RevokedAt)
if err != nil {
return apperr.WrapPostgres(err, "failed to revoke refresh tokens")
}
return nil
}
@@ -0,0 +1,103 @@
package storage
import (
"context"
"errors"
"github.com/google/uuid"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
)
type UsersRepo struct {
pool *pgxpool.Pool
}
func NewUsersRepo(pool *pgxpool.Pool) *UsersRepo {
return &UsersRepo{pool: pool}
}
func (r *UsersRepo) Create(ctx context.Context, req dto.CreateStoredUser) error {
return r.create(ctx, r.pool, req)
}
func (r *UsersRepo) CreateTx(ctx context.Context, tx pgx.Tx, req dto.CreateStoredUser) error {
return r.create(ctx, tx, req)
}
func (r *UsersRepo) GetByID(ctx context.Context, id uuid.UUID) (*dto.User, error) {
return r.getByID(ctx, r.pool, id)
}
func (r *UsersRepo) GetByIDTx(ctx context.Context, tx pgx.Tx, id uuid.UUID) (*dto.User, error) {
return r.getByID(ctx, tx, id)
}
func (r *UsersRepo) GetByUsername(ctx context.Context, username string) (*dto.User, error) {
const query = `SELECT id, username, name, created_at FROM users WHERE username = $1`
return scanUser(r.pool.QueryRow(ctx, query, username))
}
func (r *UsersRepo) GetCredentialsByUsername(ctx context.Context, username string) (*dto.UserCredentials, error) {
const query = `SELECT id, username, name, created_at, password_hash FROM users WHERE username = $1`
var credentials dto.UserCredentials
err := r.pool.QueryRow(ctx, query, username).Scan(
&credentials.User.ID,
&credentials.User.Username,
&credentials.User.DisplayName,
&credentials.User.CreatedAt,
&credentials.PasswordHash,
)
if err != nil {
return nil, apperr.WrapPostgres(err, "failed to get user credentials")
}
return &credentials, nil
}
func (r *UsersRepo) Delete(ctx context.Context, id uuid.UUID) error {
const query = `DELETE FROM users WHERE id = $1`
ct, err := r.pool.Exec(ctx, query, id)
if err != nil {
return apperr.WrapPostgres(err, "failed to delete user")
}
if ct.RowsAffected() == 0 {
return apperr.New(apperr.CodeNotFound, "user not found")
}
return nil
}
func (r *UsersRepo) create(ctx context.Context, conn postgres.Conn, req dto.CreateStoredUser) error {
const query = `INSERT INTO users (id, username, name, password_hash, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6)`
_, err := conn.Exec(ctx, query, req.ID, req.Username, req.DisplayName, req.PasswordHash, req.CreatedAt, req.UpdatedAt)
if err != nil {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok &&
pgErr.Code == pgerrcode.UniqueViolation && pgErr.ConstraintName == "users_username_unique" {
return apperr.Wrap(err, apperr.CodeConflict, "username already exists")
}
return apperr.WrapPostgres(err, "failed to create user")
}
return nil
}
func (r *UsersRepo) getByID(ctx context.Context, conn postgres.Conn, id uuid.UUID) (*dto.User, error) {
const query = `SELECT id, username, name, created_at FROM users WHERE id = $1`
return scanUser(conn.QueryRow(ctx, query, id))
}
func scanUser(row pgx.Row) (*dto.User, error) {
var user dto.User
if err := row.Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt); err != nil {
return nil, apperr.WrapPostgres(err, "failed to get user")
}
return &user, nil
}
+7
View File
@@ -0,0 +1,7 @@
package config
import "github.com/spf13/viper"
type Loader interface {
loadConfig(v *viper.Viper) error
}
+63
View File
@@ -0,0 +1,63 @@
package config
import (
"errors"
"time"
"github.com/spf13/viper"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
)
type Application struct {
LogLevel string
ShutdownTimeout time.Duration
Environment environment.ApplicationEnvironment
RequestRateLimit float64
BurstRateLimit int
RateLimitTTL time.Duration
}
func (c *Application) Validate() error {
environmentErr := c.Environment.Validate()
switch {
case c.LogLevel == "":
return wrapValidationError("application", errors.New("log_level cannot be empty in application config"))
case c.ShutdownTimeout == 0:
return wrapValidationError("application", errors.New("shutdown_timeout cannot be zero in application config"))
case environmentErr != nil:
return wrapValidationError("application", environmentErr)
//case c.RequestRateLimit == 0:
// return wrapValidationError("application", errors.New("request_rate_limit cannot be zero in application config"))
//case c.BurstRateLimit == 0:
// return wrapValidationError("application", errors.New("burst_rate_limit cannot be zero in application config"))
//case c.RateLimitTTL == 0:
// return wrapValidationError("application", errors.New("rate_limit_ttl cannot be zero in application config"))
default:
return nil
}
}
func (c *Application) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("APPLICATION")
c.LogLevel = v.GetString("LOG_LEVEL")
c.ShutdownTimeout = v.GetDuration("SHUTDOWN_TIMEOUT")
c.Environment = environment.ParseEnvironment(v.GetString("ENVIRONMENT"))
// todo add cool value
c.RequestRateLimit = v.GetFloat64("REQUEST_RATE_LIMIT")
c.BurstRateLimit = v.GetInt("BURST_RATE_LIMIT")
c.RateLimitTTL = v.GetDuration("RATE_LIMIT_TTL")
return nil
}
func (c *Application) copy() *Application {
return &Application{
LogLevel: c.LogLevel,
ShutdownTimeout: c.ShutdownTimeout,
Environment: c.Environment,
RequestRateLimit: c.RequestRateLimit,
BurstRateLimit: c.BurstRateLimit,
RateLimitTTL: c.RateLimitTTL,
}
}
+58
View File
@@ -0,0 +1,58 @@
package config
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
type Attachment struct {
Endpoint, Region, Bucket, AccessKey, SecretKey string
MaxBytes, MaxPixels int64
Timeout, Grace time.Duration
Uploads, Decoders int
}
func LoadAttachment() (*Attachment, error) {
c := &Attachment{Endpoint: env("S3_ENDPOINT", "http://s3:9000"), Region: env("S3_REGION", "us-east-1"), Bucket: env("S3_BUCKET", "messenger-attachments"), MaxBytes: 10485760, MaxPixels: 40000000, Timeout: 120 * time.Second, Grace: time.Hour, Uploads: 4, Decoders: 1}
var err error
for key, dst := range map[string]*string{"S3_ACCESS_KEY_ID_FILE": &c.AccessKey, "S3_SECRET_ACCESS_KEY_FILE": &c.SecretKey} {
b, e := os.ReadFile(os.Getenv(key))
if e != nil {
return nil, fmt.Errorf("read %s: %w", key, e)
}
*dst = strings.TrimSpace(string(b))
if *dst == "" {
return nil, fmt.Errorf("empty %s", key)
}
}
for key, dst := range map[string]*int64{"MAX_UPLOAD_BYTES": &c.MaxBytes, "MAX_IMAGE_PIXELS": &c.MaxPixels} {
if v := os.Getenv(key); v != "" {
*dst, err = strconv.ParseInt(v, 10, 64)
if err != nil {
return nil, fmt.Errorf("invalid %s", key)
}
}
}
for key, dst := range map[string]*time.Duration{"UPLOAD_TIMEOUT": &c.Timeout, "RECONCILE_GRACE_PERIOD": &c.Grace} {
if v := os.Getenv(key); v != "" {
*dst, err = time.ParseDuration(v)
if err != nil {
return nil, fmt.Errorf("invalid %s", key)
}
}
}
if c.MaxBytes < 1 || c.MaxBytes > 10485760 || c.MaxPixels < 1 || c.MaxPixels > 40000000 || c.Timeout < time.Second || c.Timeout > 120*time.Second || c.Grace <= 2*c.Timeout {
return nil, fmt.Errorf("invalid attachment limits or grace period")
}
return c, nil
}
func env(k, d string) string {
if v := os.Getenv(k); v != "" {
return v
}
return d
}
+110
View File
@@ -0,0 +1,110 @@
package config
import (
"strings"
"time"
"github.com/spf13/viper"
"go.uber.org/multierr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
)
var defaultConfig = &Config{
Server: &Server{
Host: "localhost",
Port: 8001,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 10 * time.Second,
ShutdownTimeout: 10 * time.Second,
Enabled: false,
},
Postgres: &Postgres{
Host: "localhost",
Port: 5432,
User: "postgres",
Password: "postgres",
Database: "postgres",
VersionTable: "versions",
RunMigrations: false,
MaxConnections: 10,
ConnectTimeout: 500 * time.Millisecond,
QueryTimeout: 2 * time.Second,
},
Redis: &Redis{
Host: "localhost",
Port: 6379,
Username: "",
Password: "",
DB: 0,
},
JWT: &JWT{
AccessTokenLifetime: 4 * time.Hour,
RefreshTokenLifetime: time.Hour,
PublicKeyPath: "certs/private.pem",
PrivateKeyPath: "certs/public.pem",
},
Application: &Application{
LogLevel: "info",
ShutdownTimeout: 10 * time.Second,
Environment: environment.ApplicationEnvironmentDev,
RequestRateLimit: 100,
},
}
type Config struct {
Server *Server
Postgres *Postgres
Redis *Redis
JWT *JWT
Application *Application
}
func New() (*Config, error) {
v := viper.New()
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
v.AutomaticEnv()
cfg := defaultConfig.copy()
if err := cfg.loadConfig(v); err != nil {
return nil, err
}
if err := cfg.Validate(); err != nil {
return nil, err
}
return cfg, nil
}
func (c *Config) Validate() error {
return multierr.Combine(
c.Server.Validate(),
c.Postgres.Validate(),
c.JWT.Validate(),
c.Redis.Validate(),
c.Application.Validate(),
)
}
func (c *Config) loadConfig(v *viper.Viper) error {
return multierr.Combine(
c.Postgres.loadConfig(v),
c.Server.loadConfig(v),
c.JWT.loadConfig(v),
c.Redis.loadConfig(v),
c.Application.loadConfig(v),
)
}
func (c *Config) copy() *Config {
return &Config{
Server: c.Server.copy(),
Postgres: c.Postgres.copy(),
Redis: c.Redis.copy(),
JWT: c.JWT.copy(),
Application: c.Application.copy(),
}
}
+65
View File
@@ -0,0 +1,65 @@
package config
import (
"errors"
"net/http"
"strings"
"github.com/spf13/viper"
)
type Cookies struct {
Enabled bool
Domain string
Path string
Secure bool
SameSite http.SameSite
AllowedOrigins []string
}
func (c *Cookies) Validate() error {
switch {
case c.Domain == "":
return wrapValidationError("cookies", errors.New("domain cannot be empty"))
case c.Path == "":
return wrapValidationError("cookies", errors.New("path cannot be empty"))
case c.SameSite == http.SameSiteDefaultMode:
return wrapValidationError("cookies", errors.New("same_site_set_to_none_mode cannot be empty"))
//case c.Enabled && !c.Secure:
// return wrapValidationError("cookies", errors.New("if cookies_enabled equals true then cookies_secure must be true"))
case c.AllowedOrigins == nil || len(c.AllowedOrigins) == 0:
return wrapValidationError("cookies", errors.New("allowed_origins cannot be empty"))
default:
return nil
}
}
func (c *Cookies) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("COOKIES")
c.Enabled = v.GetBool("ENABLED")
c.Domain = v.GetString("DOMAIN")
c.Path = v.GetString("PATH")
c.Secure = v.GetBool("SECURE")
c.AllowedOrigins = v.GetStringSlice("ALLOWED_ORIGINS")
sameSite := v.GetString("SAME_SITE")
switch strings.ToLower(strings.TrimSpace(sameSite)) {
case "strict":
c.SameSite = http.SameSiteStrictMode
case "none":
c.SameSite = http.SameSiteNoneMode
default:
c.SameSite = http.SameSiteLaxMode
}
return nil
}
func (c *Cookies) copy() *Cookies {
return &Cookies{
Enabled: c.Enabled,
Domain: c.Domain,
Path: c.Path,
Secure: c.Secure,
SameSite: c.SameSite,
AllowedOrigins: c.AllowedOrigins,
}
}
+63
View File
@@ -0,0 +1,63 @@
package config
import (
"errors"
"os"
"strconv"
"time"
"github.com/spf13/viper"
)
type JWT struct {
AccessTokenLifetime time.Duration
RefreshTokenLifetime time.Duration
PublicKeyPath string
PrivateKeyPath string
}
func (c *JWT) Validate() error {
switch {
case c.AccessTokenLifetime <= 0:
return wrapValidationError("jwt", errors.New("access_token_lifetime cannot be empty"))
case c.RefreshTokenLifetime <= 0:
return wrapValidationError("jwt", errors.New("refresh_token_lifetime cannot be empty"))
case c.PrivateKeyPath == "":
return wrapValidationError("jwt", errors.New("private_key_path cannot be empty"))
case c.PublicKeyPath == "":
return wrapValidationError("jwt", errors.New("public_key_path cannot be empty"))
default:
return nil
}
}
func (c *JWT) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("JWT")
c.AccessTokenLifetime = v.GetDuration("ACCESS_TOKEN_LIFETIME")
c.RefreshTokenLifetime = time.Hour
if value := os.Getenv("SESSION_TTL_SECONDS"); value != "" {
seconds, err := strconv.ParseInt(value, 10, 64)
if err != nil || seconds <= 0 || seconds > int64((1<<63-1)/time.Second) {
return wrapValidationError("session", errors.New("SESSION_TTL_SECONDS must be a positive integer duration in seconds"))
}
c.RefreshTokenLifetime = time.Duration(seconds) * time.Second
} else if legacy := v.GetString("REFRESH_TOKEN_LIFETIME"); legacy != "" {
duration, err := time.ParseDuration(legacy)
if err != nil {
return wrapValidationError("jwt", errors.New("invalid refresh_token_lifetime"))
}
c.RefreshTokenLifetime = duration
}
c.PublicKeyPath = v.GetString("PUBLIC_KEY_PATH")
c.PrivateKeyPath = v.GetString("PRIVATE_KEY_PATH")
return nil
}
func (c *JWT) copy() *JWT {
return &JWT{
AccessTokenLifetime: c.AccessTokenLifetime,
RefreshTokenLifetime: c.RefreshTokenLifetime,
PublicKeyPath: c.PublicKeyPath,
PrivateKeyPath: c.PrivateKeyPath,
}
}
+110
View File
@@ -0,0 +1,110 @@
package config
import (
"errors"
"fmt"
"math"
"time"
"github.com/spf13/viper"
)
const (
uri = "postgres://%s:%s@%s:%d/%s?sslmode=disable"
)
type Postgres struct {
Host string
Port int
User string
Password string
Database string
VersionTable string
RunMigrations bool
MaxConnections int
ConnectTimeout time.Duration
QueryTimeout time.Duration
}
func (c *Postgres) Validate() error {
switch {
case c.Host == "":
return wrapValidationError("postgres", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("postgres", errors.New("port cannot be empty"))
case c.User == "":
return wrapValidationError("postgres", errors.New("user cannot be empty"))
case c.Password == "":
return wrapValidationError("postgres", errors.New("password cannot be empty"))
case c.Database == "":
return wrapValidationError("postgres", errors.New("database cannot be empty"))
case c.VersionTable == "":
return wrapValidationError("postgres", errors.New("version_table name cannot be empty"))
case c.MaxConnections <= 0 || int64(c.MaxConnections) > math.MaxInt32:
return wrapValidationError("postgres", errors.New("max_connections must be between 1 and 2147483647"))
case c.ConnectTimeout <= 0:
return wrapValidationError("postgres", errors.New("connect_timeout must be positive"))
case c.QueryTimeout < time.Millisecond:
return wrapValidationError("postgres", errors.New("query_timeout must be at least 1ms"))
default:
return nil
}
}
func (c *Postgres) GetMaxConnections() int32 { return int32(c.MaxConnections) }
func (c *Postgres) GetConnectTimeout() time.Duration { return c.ConnectTimeout }
func (c *Postgres) GetQueryTimeout() time.Duration { return c.QueryTimeout }
func (c *Postgres) GetVersionTableName() string {
if c == nil {
return ""
}
return c.VersionTable
}
func (c *Postgres) GetURI() string {
if c == nil {
return ""
}
return fmt.Sprintf(uri, c.User, c.Password, c.Host, c.Port, c.Database)
}
func (c *Postgres) GetRunMigrations() bool {
if c == nil {
return false
}
return c.RunMigrations
}
func (c *Postgres) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("POSTGRES")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.User = v.GetString("USER")
c.Password = v.GetString("PASSWORD")
c.Database = v.GetString("DATABASE")
c.VersionTable = v.GetString("VERSION_TABLE")
c.RunMigrations = v.GetBool("RUN_MIGRATIONS")
c.MaxConnections = v.GetInt("MAX_CONNECTIONS")
c.ConnectTimeout = v.GetDuration("CONNECT_TIMEOUT")
c.QueryTimeout = v.GetDuration("QUERY_TIMEOUT")
return nil
}
func (c *Postgres) copy() *Postgres {
if c == nil {
return nil
}
return &Postgres{
Host: c.Host,
Port: c.Port,
User: c.User,
Password: c.Password,
Database: c.Database,
MaxConnections: c.MaxConnections,
ConnectTimeout: c.ConnectTimeout,
QueryTimeout: c.QueryTimeout,
RunMigrations: c.RunMigrations,
VersionTable: c.VersionTable,
}
}
+72
View File
@@ -0,0 +1,72 @@
package config
import (
"errors"
"fmt"
"net"
"time"
"github.com/redis/go-redis/v9"
"github.com/spf13/viper"
)
type Redis struct {
Host string
Port int
Username string
Password string
DB int
}
func (c *Redis) Validate() error {
switch {
case c.Host == "":
return wrapValidationError("redis", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("redis", errors.New("port cannot be empty"))
default:
return nil
}
}
func (c *Redis) BuildRedisOptions() *redis.Options {
if c == nil {
return nil
}
return &redis.Options{
Addr: net.JoinHostPort(c.Host, fmt.Sprintf("%d", c.Port)),
Username: c.Username,
Password: c.Password,
DB: c.DB,
DialTimeout: 200 * time.Millisecond,
ReadTimeout: 200 * time.Millisecond,
WriteTimeout: 200 * time.Millisecond,
PoolTimeout: 200 * time.Millisecond,
MaxRetries: -1,
DialerRetries: 1,
ContextTimeoutEnabled: true,
}
}
func (c *Redis) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("REDIS")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.DB = v.GetInt("DB")
c.Password = v.GetString("PASSWORD")
c.Username = v.GetString("USERNAME")
return nil
}
func (c *Redis) copy() *Redis {
if c == nil {
return nil
}
return &Redis{
Host: c.Host,
Port: c.Port,
Username: c.Username,
Password: c.Password,
DB: c.DB,
}
}
+69
View File
@@ -0,0 +1,69 @@
package config
import (
"errors"
"fmt"
"time"
"github.com/spf13/viper"
)
type Server struct {
Host string
Port int
ReadTimeout time.Duration
WriteTimeout time.Duration
IdleTimeout time.Duration
ShutdownTimeout time.Duration
Enabled bool
}
func (c *Server) Validate() error {
if !c.Enabled {
return nil
}
switch {
case c.Host == "":
return wrapValidationError("server", errors.New("host cannot be empty"))
case c.Port == 0:
return wrapValidationError("server", errors.New("port cannot be empty"))
case c.ReadTimeout == 0:
return wrapValidationError("server", errors.New("read_timeout cannot be empty"))
case c.WriteTimeout == 0:
return wrapValidationError("server", errors.New("write_timeout cannot be empty"))
case c.IdleTimeout == 0:
return wrapValidationError("server", errors.New("idle_timeout cannot be empty"))
case c.ShutdownTimeout == 0:
return wrapValidationError("server", errors.New("shutdown_timeout name cannot be empty"))
default:
return nil
}
}
func (c *Server) loadConfig(v *viper.Viper) error {
v.SetEnvPrefix("APP")
c.Host = v.GetString("HOST")
c.Port = v.GetInt("PORT")
c.ReadTimeout = v.GetDuration("READ_TIMEOUT")
c.WriteTimeout = v.GetDuration("WRITE_TIMEOUT")
c.IdleTimeout = v.GetDuration("IDLE_TIMEOUT")
c.ShutdownTimeout = v.GetDuration("SHUTDOWN_TIMEOUT")
c.Enabled = v.GetBool("ENABLED")
return c.Validate()
}
func (c *Server) BindAddress() string {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
func (c *Server) copy() *Server {
return &Server{
Host: c.Host,
Port: c.Port,
ReadTimeout: c.ReadTimeout,
WriteTimeout: c.WriteTimeout,
IdleTimeout: c.IdleTimeout,
ShutdownTimeout: c.ShutdownTimeout,
Enabled: c.Enabled,
}
}
+11
View File
@@ -0,0 +1,11 @@
package config
import "fmt"
func wrapValidationError(name string, err error) error {
if err == nil {
return nil
}
return fmt.Errorf("%s validation error: %w", name, err)
}
+1
View File
@@ -0,0 +1 @@
package dto
+126
View File
@@ -0,0 +1,126 @@
package dto
import (
"errors"
"net/netip"
"time"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
// ---- Tokens ----
type UserDataInToken struct {
TokenID uuid.UUID
UserID uuid.UUID
Role role.Role
IsAccess bool
PhoneNumber *string
Email *string
ExpiresAt time.Time
IssuedAt time.Time
}
func (u UserDataInToken) Validate() error {
if u.TokenID == uuid.Nil {
return errors.New("invalid token id")
}
if u.UserID == uuid.Nil {
return errors.New("invalid user id")
}
if !u.Role.IsValid() {
return errors.New("invalid role")
}
if u.ExpiresAt.IsZero() {
return errors.New("invalid expiry")
}
if u.IssuedAt.IsZero() {
return errors.New("invalid issued")
}
return nil
}
type Token struct {
Payload string
}
type (
AccessToken Token
RefreshToken Token
)
type Tokens struct {
AccessToken AccessToken
RefreshToken RefreshToken
}
func (t AccessToken) Token() *Token {
return new(Token(t))
}
func (t RefreshToken) Token() *Token {
return new(Token(t))
}
type StoredRefreshToken struct {
ID uuid.UUID
UserID uuid.UUID
TokenHash string
UserAgent string
IPAddress netip.Addr
Role role.Role
ExpiresAt time.Time
RevokedAt *time.Time
CreatedAt time.Time
}
type RevokeRefreshToken struct {
ID uuid.UUID
RevokedAt time.Time
}
type RevokeRefreshTokensByUserID struct {
UserID uuid.UUID
RevokedAt time.Time
}
// ---- Auth ----
type Session struct {
ExpiresAt time.Time
Token string
TokenType string
User User
}
type Login struct {
Username string
Password string
}
type LoginResult struct {
ExpiresAt time.Time
TokenType string
User User
Tokens Tokens
}
// UserCredentials is internal authentication data, never a public user response.
type UserCredentials struct {
User User
PasswordHash string `json:"-"`
}
type Logout struct {
Token string
}
type Register struct {
Email string
Password string
RepeatPassword string
}
+31
View File
@@ -0,0 +1,31 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID
Title string
MemberIDs []uuid.UUID
CreatedAt time.Time
}
type CreateChat struct {
CreatorID uuid.UUID
Title string
MemberIDs []uuid.UUID
}
type ChatMember struct {
UserID uuid.UUID
ChatID uuid.UUID
}
type ChatFilters struct {
UserID uuid.UUID
Limit *int
AfterID *uuid.UUID
}
+38
View File
@@ -0,0 +1,38 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type Message struct {
AttachmentIDs []uuid.UUID
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
type CreateMessage struct {
AttachmentIDs []uuid.UUID
IdempotencyKey string
ChatID uuid.UUID
SenderID uuid.UUID
Text string
}
type MessageFilters struct {
ChatID uuid.UUID
UserID uuid.UUID
Limit *int
AfterID *uuid.UUID
}
// MessageAttachment contains only the data needed to authorize linking an attachment.
type MessageAttachment struct {
ID uuid.UUID
ChatID uuid.UUID
Missing bool
}
+25
View File
@@ -0,0 +1,25 @@
package dto
import (
"time"
"github.com/google/uuid"
)
// Page is a page of records with the ID to use for the next page.
type Page[T any] struct {
Items []T
NextCursorID *uuid.UUID
}
// PagePosition is a resolved database cursor, ordered by creation time and ID.
type PagePosition struct {
CreatedAt time.Time
ID uuid.UUID
}
// PageQuery is prepared by a service; Limit includes the lookahead row.
type PageQuery struct {
Limit int
After *PagePosition
}
+30
View File
@@ -0,0 +1,30 @@
package dto
import (
"time"
"github.com/google/uuid"
)
type User struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
type CreateUser struct {
Username string
DisplayName string
Password string
}
// CreateStoredUser contains the prepared database record, never a plaintext password.
type CreateStoredUser struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string `json:"-"`
CreatedAt time.Time
UpdatedAt time.Time
}
+226
View File
@@ -0,0 +1,226 @@
// Package contracts provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.5.1 DO NOT EDIT.
package contracts
import (
"time"
openapi_types "github.com/oapi-codegen/runtime/types"
)
const (
BasicAuthScopes = "basicAuth.Scopes"
BearerAuthScopes = "bearerAuth.Scopes"
)
// Defines values for AttachmentContentType.
const (
AttachmentContentTypeImagejpeg AttachmentContentType = "image/jpeg"
AttachmentContentTypeImagepng AttachmentContentType = "image/png"
)
// Defines values for AttachmentStatus.
const (
Ready AttachmentStatus = "ready"
)
// Defines values for ErrorErrorCode.
const (
Conflict ErrorErrorCode = "conflict"
InternalError ErrorErrorCode = "internal_error"
InvalidRequest ErrorErrorCode = "invalid_request"
NotFound ErrorErrorCode = "not_found"
PayloadTooLarge ErrorErrorCode = "payload_too_large"
RateLimited ErrorErrorCode = "rate_limited"
Unauthorized ErrorErrorCode = "unauthorized"
Unavailable ErrorErrorCode = "unavailable"
UnsupportedMediaType ErrorErrorCode = "unsupported_media_type"
)
// Defines values for HealthStatus.
const (
Ok HealthStatus = "ok"
)
// Defines values for VariantContentType.
const (
VariantContentTypeImagejpeg VariantContentType = "image/jpeg"
VariantContentTypeImagepng VariantContentType = "image/png"
VariantContentTypeImagewebp VariantContentType = "image/webp"
)
// Defines values for VariantName.
const (
Crop VariantName = "crop"
Optimized VariantName = "optimized"
Thumbnail VariantName = "thumbnail"
)
// Defines values for DownloadAttachmentParamsVariant.
const (
Original DownloadAttachmentParamsVariant = "original"
)
// Attachment defines model for Attachment.
type Attachment struct {
ChatId openapi_types.UUID `json:"chat_id"`
ContentType AttachmentContentType `json:"content_type"`
CreatedAt time.Time `json:"created_at"`
ErrorCode *string `json:"error_code"`
Filename string `json:"filename"`
Id openapi_types.UUID `json:"id"`
OwnerId openapi_types.UUID `json:"owner_id"`
Sha256 string `json:"sha256"`
SizeBytes int `json:"size_bytes"`
Status AttachmentStatus `json:"status"`
UpdatedAt time.Time `json:"updated_at"`
Variants []Variant `json:"variants"`
}
// AttachmentContentType defines model for Attachment.ContentType.
type AttachmentContentType string
// AttachmentStatus defines model for Attachment.Status.
type AttachmentStatus string
// Chat defines model for Chat.
type Chat struct {
CreatedAt time.Time `json:"created_at"`
Id openapi_types.UUID `json:"id"`
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// ChatPage defines model for ChatPage.
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// CreateChat defines model for CreateChat.
type CreateChat struct {
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// CreateMessage defines model for CreateMessage.
type CreateMessage struct {
AttachmentIds *[]openapi_types.UUID `json:"attachment_ids,omitempty"`
Text *string `json:"text,omitempty"`
}
// CreateUser defines model for CreateUser.
type CreateUser struct {
DisplayName string `json:"display_name"`
Password *string `json:"password,omitempty"`
Username string `json:"username"`
}
// Error defines model for Error.
type Error struct {
Error struct {
Code ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
} `json:"error"`
}
// ErrorErrorCode defines model for Error.Error.Code.
type ErrorErrorCode string
// Health defines model for Health.
type Health struct {
Status HealthStatus `json:"status"`
}
// HealthStatus defines model for Health.Status.
type HealthStatus string
// Message defines model for Message.
type Message struct {
AttachmentIds []openapi_types.UUID `json:"attachment_ids"`
ChatId openapi_types.UUID `json:"chat_id"`
CreatedAt time.Time `json:"created_at"`
Id openapi_types.UUID `json:"id"`
SenderId openapi_types.UUID `json:"sender_id"`
Text string `json:"text"`
}
// MessagePage defines model for MessagePage.
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// Session defines model for Session.
type Session struct {
ExpiresAt time.Time `json:"expires_at"`
Token string `json:"token"`
TokenType string `json:"token_type"`
User User `json:"user"`
}
// User defines model for User.
type User struct {
CreatedAt time.Time `json:"created_at"`
DisplayName string `json:"display_name"`
Id openapi_types.UUID `json:"id"`
Username string `json:"username"`
}
// Variant defines model for Variant.
type Variant struct {
ContentType VariantContentType `json:"content_type"`
Height int `json:"height"`
Name VariantName `json:"name"`
Sha256 string `json:"sha256"`
SizeBytes int `json:"size_bytes"`
Width int `json:"width"`
}
// VariantContentType defines model for Variant.ContentType.
type VariantContentType string
// VariantName defines model for Variant.Name.
type VariantName string
// DownloadAttachmentParams defines parameters for DownloadAttachment.
type DownloadAttachmentParams struct {
Variant *DownloadAttachmentParamsVariant `form:"variant,omitempty" json:"variant,omitempty"`
}
// DownloadAttachmentParamsVariant defines parameters for DownloadAttachment.
type DownloadAttachmentParamsVariant string
// ListChatsParams defines parameters for ListChats.
type ListChatsParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// UploadAttachmentParams defines parameters for UploadAttachment.
type UploadAttachmentParams struct {
Filename string `form:"filename" json:"filename"`
}
// ListMessagesParams defines parameters for ListMessages.
type ListMessagesParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// CreateMessageParams defines parameters for CreateMessage.
type CreateMessageParams struct {
// IdempotencyKey Обязателен с lab3. Область: пользователь + метод + путь + ключ; хранить результат не менее 24 ч. Повтор того же JSON возвращает исходный 201 и то же сообщение, другой JSON — 409.
IdempotencyKey string `json:"Idempotency-Key"`
}
// CreateChatJSONRequestBody defines body for CreateChat for application/json ContentType.
type CreateChatJSONRequestBody = CreateChat
// CreateMessageJSONRequestBody defines body for CreateMessage for application/json ContentType.
type CreateMessageJSONRequestBody = CreateMessage
// RegisterUserJSONRequestBody defines body for RegisterUser for application/json ContentType.
type RegisterUserJSONRequestBody = CreateUser
+274
View File
@@ -0,0 +1,274 @@
package apperr
import (
"errors"
"net/http"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
grpcCodes "google.golang.org/grpc/codes"
)
//go:generate stringer -type=Code -linecomment
type Code uint16
const (
// CodeBadRequest = {AppError: BAD_REQUEST, HTTP:400}
CodeBadRequest Code = iota
// CodePayloadTooLarge = {AppError: REQUEST_ENTITY_TOO_LARGE, HTTP:413}
CodePayloadTooLarge
// CodeValidation = {AppError: VALIDATION, HTTP:400}
CodeValidation
// CodeUnauthorized = {AppError: UNAUTHORIZED, HTTP:401}
CodeUnauthorized
// CodeForbidden = {AppError: FORBIDDEN, HTTP:403}
CodeForbidden
// CodeNotFound = {AppError: NOT_FOUND, HTTP:404}
CodeNotFound
// CodeAlreadyExists = {AppError: ALREADY_EXISTS, HTTP:409}
CodeAlreadyExists
// CodeConflict = {AppError: CONFLICT, HTTP:409}
CodeConflict
// CodeTooManyRequests = {AppError: TOO_MANY_REQUESTS, HTTP:429}
CodeTooManyRequests
// CodeTimeout = {AppError: TIMEOUT, HTTP:504}
CodeTimeout
// CodeInternal = {AppError: INTERNAL, HTTP:500}
CodeInternal
// CodeServiceUnavailable = {AppError: SERVICE_UNAVAILABLE, HTTP:503}
CodeServiceUnavailable
// CodeOK = {AppError: OK, HTTP:200}
CodeOK
// CodeLocked = {AppError: LOCKED, HTTP:423}
CodeLocked
// CodeUnsupportedMediaType = {AppError: UNSUPPORTED_MEDIA_TYPE, HTTP:415}
CodeUnsupportedMediaType
// CodeUnavailable = {AppError: SERVICE_UNAVAILABLE, HTTP: 503}
CodeUnavailable
)
func (c Code) HTTPStatus() int {
if status, ok := httpStatusByCode[c]; ok {
return status
}
return http.StatusInternalServerError
}
func (c Code) GRPCCode() grpcCodes.Code {
if code, ok := grpcCodeByCode[c]; ok {
return code
}
return grpcCodes.Internal
}
func (c Code) PostgresCodes() []string {
codes := postgresCodesByCode[c]
if len(codes) == 0 {
return nil
}
cp := make([]string, len(codes))
copy(cp, codes)
return cp
}
func (c Code) PostgresCode() string {
codes := c.PostgresCodes()
if len(codes) == 0 {
return ""
}
return codes[0]
}
func CodeFromError(err error) Code {
if err == nil {
return CodeInternal
}
var coded interface {
Code() Code
}
if errors.As(err, &coded) {
return coded.Code()
}
if code, ok := codeFromRedisError(err, false, false); ok {
return code
}
return CodeFromPostgresError(err)
}
func HTTPStatusFromError(err error) int {
return CodeFromError(err).HTTPStatus()
}
func GRPCCodeFromError(err error) grpcCodes.Code {
return CodeFromError(err).GRPCCode()
}
func CodeFromHTTPStatus(status int) Code {
if code, ok := codeByHTTPStatus[status]; ok {
return code
}
return CodeInternal
}
func CodeFromGRPC(code grpcCodes.Code) Code {
if appCode, ok := codeByGRPCCode[code]; ok {
return appCode
}
return CodeInternal
}
func CodeFromPostgres(pgCode string) Code {
if code, ok := codeByPostgresCode[pgCode]; ok {
return code
}
return CodeInternal
}
func CodeFromPostgresError(err error) Code {
if err == nil {
return CodeInternal
}
if code, ok := codeByPgxError[err]; ok {
return code
}
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
return CodeFromPostgres(pgErr.Code)
}
return CodeInternal
}
var (
httpStatusByCode = map[Code]int{
CodeBadRequest: http.StatusBadRequest,
CodeUnauthorized: http.StatusUnauthorized,
CodeForbidden: http.StatusForbidden,
CodeNotFound: http.StatusNotFound,
CodeAlreadyExists: http.StatusConflict,
CodeConflict: http.StatusConflict,
CodePayloadTooLarge: http.StatusRequestEntityTooLarge,
CodeTooManyRequests: http.StatusTooManyRequests,
CodeValidation: http.StatusBadRequest,
CodeTimeout: http.StatusGatewayTimeout,
CodeInternal: http.StatusInternalServerError,
CodeServiceUnavailable: http.StatusServiceUnavailable,
CodeUnsupportedMediaType: http.StatusUnsupportedMediaType,
CodeUnavailable: http.StatusServiceUnavailable,
CodeOK: http.StatusOK,
CodeLocked: http.StatusLocked,
}
codeByHTTPStatus = map[int]Code{
http.StatusBadRequest: CodeBadRequest,
http.StatusUnauthorized: CodeUnauthorized,
http.StatusForbidden: CodeForbidden,
http.StatusNotFound: CodeNotFound,
http.StatusConflict: CodeConflict,
http.StatusRequestEntityTooLarge: CodePayloadTooLarge,
http.StatusTooManyRequests: CodeTooManyRequests,
http.StatusUnprocessableEntity: CodeValidation,
http.StatusGatewayTimeout: CodeTimeout,
http.StatusInternalServerError: CodeInternal,
http.StatusServiceUnavailable: CodeServiceUnavailable,
http.StatusOK: CodeOK,
http.StatusLocked: CodeLocked,
http.StatusUnsupportedMediaType: CodeUnavailable,
}
grpcCodeByCode = map[Code]grpcCodes.Code{
CodeBadRequest: grpcCodes.InvalidArgument,
CodePayloadTooLarge: grpcCodes.ResourceExhausted,
CodeValidation: grpcCodes.InvalidArgument,
CodeUnauthorized: grpcCodes.Unauthenticated,
CodeForbidden: grpcCodes.PermissionDenied,
CodeNotFound: grpcCodes.NotFound,
CodeAlreadyExists: grpcCodes.AlreadyExists,
CodeConflict: grpcCodes.Aborted,
CodeTooManyRequests: grpcCodes.ResourceExhausted,
CodeTimeout: grpcCodes.DeadlineExceeded,
CodeInternal: grpcCodes.Internal,
CodeServiceUnavailable: grpcCodes.Unavailable,
CodeOK: grpcCodes.OK,
CodeLocked: grpcCodes.FailedPrecondition,
}
codeByGRPCCode = map[grpcCodes.Code]Code{
grpcCodes.InvalidArgument: CodeBadRequest,
grpcCodes.ResourceExhausted: CodeTooManyRequests,
grpcCodes.Unauthenticated: CodeUnauthorized,
grpcCodes.PermissionDenied: CodeForbidden,
grpcCodes.NotFound: CodeNotFound,
grpcCodes.AlreadyExists: CodeAlreadyExists,
grpcCodes.Aborted: CodeConflict,
grpcCodes.FailedPrecondition: CodeLocked,
grpcCodes.DeadlineExceeded: CodeTimeout,
grpcCodes.Internal: CodeInternal,
grpcCodes.Unimplemented: CodeInternal,
grpcCodes.Unavailable: CodeServiceUnavailable,
grpcCodes.OK: CodeOK,
}
postgresCodesByCode = map[Code][]string{
CodeBadRequest: {
pgerrcode.InvalidTextRepresentation,
pgerrcode.InvalidParameterValue,
},
CodeValidation: {
pgerrcode.NotNullViolation,
pgerrcode.CheckViolation,
pgerrcode.StringDataRightTruncationDataException,
pgerrcode.NumericValueOutOfRange,
},
CodeNotFound: {
pgerrcode.ForeignKeyViolation,
},
CodeAlreadyExists: {
pgerrcode.UniqueViolation,
},
CodeConflict: {
pgerrcode.ExclusionViolation,
pgerrcode.SerializationFailure,
pgerrcode.DeadlockDetected,
},
CodeLocked: {
pgerrcode.LockNotAvailable,
pgerrcode.ObjectInUse,
},
CodeTooManyRequests: {
pgerrcode.TooManyConnections,
},
CodeTimeout: {
pgerrcode.QueryCanceled,
},
CodeInternal: {
pgerrcode.ConnectionException,
pgerrcode.ConnectionFailure,
pgerrcode.SQLClientUnableToEstablishSQLConnection,
pgerrcode.SQLServerRejectedEstablishmentOfSQLConnection,
pgerrcode.TransactionResolutionUnknown,
},
CodeServiceUnavailable: {
pgerrcode.CannotConnectNow,
},
}
codeByPostgresCode = buildCodeByPostgresCode(postgresCodesByCode)
codeByPgxError = map[error]Code{
pgx.ErrNoRows: CodeNotFound,
pgx.ErrTxClosed: CodeInternal,
pgx.ErrTxCommitRollback: CodeConflict,
pgx.ErrTooManyRows: CodeInternal,
}
)
func buildCodeByPostgresCode(src map[Code][]string) map[string]Code {
dst := make(map[string]Code, len(src))
for code, pgCodes := range src {
for _, pgCode := range pgCodes {
dst[pgCode] = code
}
}
return dst
}
@@ -0,0 +1,37 @@
// Code generated by "stringer -type=Code -linecomment"; DO NOT EDIT.
package apperr
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[CodeBadRequest-0]
_ = x[CodePayloadTooLarge-1]
_ = x[CodeValidation-2]
_ = x[CodeUnauthorized-3]
_ = x[CodeForbidden-4]
_ = x[CodeNotFound-5]
_ = x[CodeAlreadyExists-6]
_ = x[CodeConflict-7]
_ = x[CodeTooManyRequests-8]
_ = x[CodeTimeout-9]
_ = x[CodeInternal-10]
_ = x[CodeServiceUnavailable-11]
_ = x[CodeOK-12]
_ = x[CodeLocked-13]
}
const _Code_name = "CodeBadRequestCodePayloadTooLargeCodeValidationCodeUnauthorizedCodeForbiddenCodeNotFoundCodeAlreadyExistsCodeConflictCodeTooManyRequestsCodeTimeoutCodeInternalCodeServiceUnavailableCodeOKCodeLocked"
var _Code_index = [...]uint8{0, 14, 33, 47, 63, 76, 88, 105, 117, 136, 147, 159, 181, 187, 197}
func (i Code) String() string {
idx := int(i) - 0
if i < 0 || idx >= len(_Code_index)-1 {
return "Code(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _Code_name[_Code_index[idx]:_Code_index[idx+1]]
}
+123
View File
@@ -0,0 +1,123 @@
package apperr
import (
"errors"
"fmt"
grpcCodes "google.golang.org/grpc/codes"
)
type AppError struct {
err error
msg string
code Code
meta metadata
}
func New(code Code, msg string) error {
return &AppError{
msg: msg,
code: code,
meta: metadata{},
}
}
func Wrap(err error, code Code, msg string) error {
m := AppError{
err: err,
msg: msg,
code: code,
meta: metadata{},
}
return &m
}
func WrapAppError(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
code: CodeInternal,
meta: metadata{},
}
if mistake := As(err); mistake != nil {
m.err = mistake
m.code = mistake.code
m.meta = mistake.meta
}
return &m
}
func As(err error) *AppError {
if mistakeErr, ok := errors.AsType[*AppError](err); ok {
return mistakeErr
}
return nil
}
func CodeIs(err error, code Code) bool {
if appErr := As(err); appErr != nil && appErr.Code() == code {
return true
}
return false
}
func (e *AppError) Error() string {
if e == nil {
return ""
}
if e.err == nil {
if e.msg != "" {
return e.msg
}
return e.code.String()
}
if e.msg == "" {
return e.err.Error()
}
return fmt.Sprintf("%s: %s", e.msg, e.err.Error())
}
func (e *AppError) Unwrap() error {
if e == nil {
return nil
}
return e.err
}
func (e *AppError) Code() Code {
if e == nil {
return CodeInternal
}
return e.code
}
func (e *AppError) Message() string {
if e == nil {
return ""
}
return e.msg
}
func (e *AppError) Cause() error {
if e == nil {
return nil
}
return e.err
}
func (e *AppError) Metadata() Metadata {
return e.meta
}
func (e *AppError) HTTPStatus() int {
return e.Code().HTTPStatus()
}
func (e *AppError) GRPCCode() grpcCodes.Code {
return e.Code().GRPCCode()
}
+42
View File
@@ -0,0 +1,42 @@
package apperr
import (
"fmt"
"maps"
"strings"
)
var _ Metadata = (*metadata)(nil)
type Metadata interface {
Get(key metakey) string
Clone() map[metakey]string
CloneToAnyMap() map[string]any
String() string
}
type metadata map[metakey]string
func (m metadata) Get(key metakey) string {
return m[key]
}
func (m metadata) Clone() map[metakey]string {
return maps.Clone(m)
}
func (m metadata) CloneToAnyMap() map[string]any {
newM := make(map[string]any, len(m))
for k, v := range m {
newM[k.String()] = v
}
return newM
}
func (m metadata) String() string {
var b strings.Builder
for k, v := range m {
b.WriteString(fmt.Sprintf("%s: %s, ", k, v))
}
return b.String()
}
+19
View File
@@ -0,0 +1,19 @@
package apperr
type metakey uint16
const (
PgErrorCode metakey = iota
RedisErrorCode
)
func (m metakey) String() string {
switch m {
case PgErrorCode:
return "pg_err_code"
case RedisErrorCode:
return "redis_err_code"
default:
return "unknown"
}
}
+81
View File
@@ -0,0 +1,81 @@
package apperr
import (
"context"
"errors"
"fmt"
"io"
"net"
"strings"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
func WrapPostgres(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
code: CodeInternal,
meta: metadata{},
}
m.handlePostgres()
return &m
}
func (e *AppError) handlePostgres() {
if e.err == nil {
e.code = CodeOK
return
}
var networkError net.Error
var connectError *pgconn.ConnectError
if errors.Is(e.err, context.DeadlineExceeded) || errors.Is(e.err, io.EOF) ||
errors.Is(e.err, io.ErrUnexpectedEOF) || errors.As(e.err, &networkError) || errors.As(e.err, &connectError) {
e.code = CodeServiceUnavailable
e.msg = "database unavailable"
return
}
if pgErr, ok := errors.AsType[*pgconn.PgError](e.err); ok {
if strings.HasPrefix(pgErr.Code, "08") || pgErr.Code == "57014" ||
pgErr.Code == "57P01" || pgErr.Code == "57P02" || pgErr.Code == "57P03" || pgErr.Code == "53300" {
e.code = CodeServiceUnavailable
e.msg = "database unavailable"
return
}
e.meta[PgErrorCode] = pgErr.Code
e.code = CodeFromPostgres(pgErr.Code)
return
}
switch {
case errors.Is(e.err, pgx.ErrNoRows):
e.msg = fmt.Sprintf("not found: %s", e.msg)
e.code = CodeNotFound
return
case errors.Is(e.err, pgx.ErrTooManyRows):
e.msg = fmt.Sprintf("got too many rows: %s", e.msg)
e.code = CodeInternal
return
case errors.Is(e.err, pgx.ErrTxClosed):
e.msg = fmt.Sprintf("transaction is closed: %s", e.msg)
e.code = CodeInternal
return
case errors.Is(e.err, pgx.ErrTxCommitRollback):
e.msg = fmt.Sprintf("transaction commit resulted in rollback: %s", e.msg)
e.code = CodeInternal
return
}
}
func (e *AppError) PgCode() string {
if e == nil {
return ""
}
if e.meta == nil {
return ""
}
return e.meta.Get(PgErrorCode)
}
+170
View File
@@ -0,0 +1,170 @@
package apperr
import (
"context"
"errors"
"fmt"
"net"
"strings"
"github.com/redis/go-redis/v9"
)
func WrapRedis(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
meta: metadata{},
}
m.handleRedis()
return &m
}
func CodeFromRedisError(err error) Code {
code, ok := codeFromRedisError(err, true, true)
if !ok {
return CodeInternal
}
return code
}
func (e *AppError) handleRedis() {
if e.err == nil {
e.code = CodeOK
return
}
if code := redisErrorCode(e.err); code != "" {
e.meta[RedisErrorCode] = code
}
if errors.Is(e.err, redis.Nil) {
e.msg = fmt.Sprintf("not found: %s", e.msg)
}
e.code = CodeFromRedisError(e.err)
}
func (e *AppError) RedisCode() string {
if e == nil {
return ""
}
if e.meta == nil {
return ""
}
return e.meta.Get(RedisErrorCode)
}
func codeFromRedisError(err error, includeTransport bool, includeProtocolString bool) (Code, bool) {
if err == nil {
return CodeInternal, false
}
switch {
case errors.Is(err, redis.Nil):
return CodeNotFound, true
case errors.Is(err, redis.TxFailedErr):
return CodeConflict, true
case errors.Is(err, redis.ErrCrossSlot):
return CodeBadRequest, true
case errors.Is(err, redis.ErrPoolTimeout):
return CodeTimeout, true
case errors.Is(err, redis.ErrPoolExhausted):
return CodeTooManyRequests, true
case errors.Is(err, redis.ErrClosed):
return CodeServiceUnavailable, true
}
if includeTransport {
if errors.Is(err, context.Canceled) ||
errors.Is(err, context.DeadlineExceeded) {
return CodeTimeout, true
}
if netErr, ok := errors.AsType[net.Error](err); ok {
if netErr.Timeout() {
return CodeTimeout, true
}
return CodeServiceUnavailable, true
}
}
hasRedisError := isRedisError(err)
if !hasRedisError && !includeProtocolString {
return CodeInternal, false
}
switch {
case redis.IsExecAbortError(err):
return CodeConflict, true
case redis.IsMaxClientsError(err):
return CodeTooManyRequests, true
case redis.IsLoadingError(err),
redis.IsReadOnlyError(err),
redis.IsClusterDownError(err),
redis.IsTryAgainError(err),
redis.IsMasterDownError(err),
redis.IsNoReplicasError(err),
redis.IsOOMError(err):
return CodeServiceUnavailable, true
case redis.IsAuthError(err),
redis.IsPermissionError(err):
return CodeInternal, true
}
if _, ok := redis.IsMovedError(err); ok {
return CodeServiceUnavailable, true
}
if _, ok := redis.IsAskError(err); ok {
return CodeServiceUnavailable, true
}
if hasRedisError {
return CodeInternal, true
}
return CodeInternal, false
}
func isRedisError(err error) bool {
if err == nil {
return false
}
var redisErr redis.Error
return errors.As(err, &redisErr)
}
func redisErrorCode(err error) string {
switch {
case err == nil:
return ""
case errors.Is(err, redis.Nil):
return "nil"
case errors.Is(err, redis.TxFailedErr):
return "tx_failed"
case errors.Is(err, redis.ErrCrossSlot):
return "CROSSSLOT"
case errors.Is(err, redis.ErrPoolTimeout):
return "pool_timeout"
case errors.Is(err, redis.ErrPoolExhausted):
return "pool_exhausted"
case errors.Is(err, redis.ErrClosed):
return "closed"
}
var redisErr redis.Error
if !errors.As(err, &redisErr) {
return ""
}
msg := strings.TrimSpace(redisErr.Error())
msg = strings.TrimPrefix(msg, "ERR ")
parts := strings.Fields(msg)
if len(parts) == 0 {
return ""
}
return parts[0]
}
@@ -0,0 +1,145 @@
package jwtprovider
import (
"fmt"
"log/slog"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var _ Claims = (*jwtClaims)(nil)
type Claims interface {
GetTopTokenID() (uuid.UUID, bool)
GetTopUserID() (uuid.UUID, bool)
GetTopRole() (role.Role, bool)
GetTopIsAccess() (bool, bool)
GetTopExpiresAt() (time.Time, bool)
GetTopIssuedAt() (time.Time, bool)
}
type claimsParseFunc func(token *dto.Token) (*jwtClaims, error)
type jwtClaims struct {
jwt.RegisteredClaims
Nonce string `json:"nonce,omitempty"`
IsAccess bool `json:"is_access"`
Role role.Role `json:"role"`
}
func (claims *jwtClaims) GetTopTokenID() (uuid.UUID, bool) {
parsed, err := uuid.Parse(claims.ID)
if err != nil {
return uuid.Nil, false
}
return parsed, true
}
func (claims *jwtClaims) GetTopUserID() (uuid.UUID, bool) {
parsed, err := uuid.Parse(claims.Subject)
if err != nil {
return uuid.Nil, false
}
return parsed, true
}
func (claims *jwtClaims) GetTopRole() (role.Role, bool) {
return claims.Role, true
}
func (claims *jwtClaims) GetTopIsAccess() (bool, bool) {
return claims.IsAccess, true
}
func (claims *jwtClaims) GetTopExpiresAt() (time.Time, bool) {
if claims.ExpiresAt == nil {
return time.Time{}, false
}
return claims.ExpiresAt.Time, true
}
func (claims *jwtClaims) GetTopIssuedAt() (time.Time, bool) {
if claims.IssuedAt == nil {
return time.Time{}, false
}
return claims.IssuedAt.Time, true
}
func (claims *jwtClaims) userData() (*dto.UserDataInToken, error) {
var u dto.UserDataInToken
tokenID, err := uuid.Parse(claims.ID)
if err != nil {
return nil, fmt.Errorf("failed to parse token id: %w", err)
}
u.TokenID = tokenID
userID, err := uuid.Parse(claims.Subject)
if err != nil {
return nil, fmt.Errorf("failed to parse user id from token %q: %w", claims.Subject, err)
}
u.UserID = userID
u.Role = claims.Role
u.IsAccess = claims.IsAccess
if claims.ExpiresAt != nil {
u.ExpiresAt = claims.ExpiresAt.Time
}
if claims.IssuedAt != nil {
u.IssuedAt = claims.IssuedAt.Time
}
return &u, nil
}
func (p *provider) parseClaimsFromProtectedJWT(token *dto.Token) (*jwtClaims, error) {
if token == nil {
return nil, ErrTokenIsMissing
}
claims := &jwtClaims{}
parsed, err := jwt.ParseWithClaims(
token.Payload,
claims,
p.readKeyFunc,
jwt.WithValidMethods([]string{jwt.SigningMethodRS256.Alg()}),
jwt.WithExpirationRequired(),
jwt.WithIssuedAt(),
)
if err != nil {
slog.Error("failed to parse token with claims", "error", err)
return nil, ErrInvalidToken
}
if !parsed.Valid {
slog.Error("failed to parse token: provided invalid token", "valid", parsed.Valid)
return nil, ErrInvalidToken
}
return claims, nil
}
func (p *provider) parseClaimsFromExposedJWT(token *dto.Token) (*jwtClaims, error) {
if token == nil {
return nil, ErrTokenIsMissing
}
claims := &jwtClaims{}
_, _, err := new(jwt.Parser).ParseUnverified(token.Payload, claims)
if err != nil {
slog.Error("failed to parse token: provided invalid token")
return nil, ErrInvalidToken
}
return claims, nil
}
@@ -0,0 +1,84 @@
package jwtprovider
import (
"net/http"
)
const (
accessTokenCookieKey = "auth-access-token"
refreshTokenCookieKey = "auth-refresh-token"
expiresAtCookieKey = "auth-exp"
)
type CookieBuilderFabric struct {
fabric func() http.Cookie
}
func newCookieBuilder(
domain string,
path string,
secure bool,
sameSite http.SameSite,
) *CookieBuilderFabric {
return &CookieBuilderFabric{
fabric: newCookieFabric(domain, path, secure, sameSite),
}
}
func (b *CookieBuilderFabric) Builder() *CookieBuilder {
return &CookieBuilder{
cookie: b.fabric(),
}
}
func newCookieFabric(
_ string,
path string,
secure bool,
sameSite http.SameSite) func() http.Cookie {
return func() http.Cookie {
return http.Cookie{
Path: path,
Secure: secure,
SameSite: sameSite,
}
}
}
type CookieBuilder struct {
cookie http.Cookie
}
func (b *CookieBuilder) AccessName() *CookieBuilder {
b.cookie.Name = accessTokenCookieKey
return b
}
func (b *CookieBuilder) ExpiresName() *CookieBuilder {
b.cookie.Name = expiresAtCookieKey
return b
}
func (b *CookieBuilder) RefreshName() *CookieBuilder {
b.cookie.Name = refreshTokenCookieKey
return b
}
func (b *CookieBuilder) Value(value string) *CookieBuilder {
b.cookie.Value = value
return b
}
func (b *CookieBuilder) HTTPOnly() *CookieBuilder {
b.cookie.HttpOnly = true
return b
}
func (b *CookieBuilder) MaxAge(maxAge int) *CookieBuilder {
b.cookie.MaxAge = maxAge
return b
}
func (b *CookieBuilder) Build() *http.Cookie {
return new(b.cookie)
}
@@ -0,0 +1,18 @@
package jwtprovider
import (
"errors"
)
var (
ErrDecode = errors.New("failed to decode argument")
ErrNotFound = errors.New("not found")
ErrUnexpectedAlgorithm = errors.New("unexpected signing algorithm")
ErrTokenIsMissing = errors.New("token is missing")
ErrInvalidToken = errors.New("provided invalid token")
ErrInvalidUserDataInToken = errors.New("invalid user data in token")
ErrInvalidTokenClaims = errors.New("provided invalid token claims")
ErrInvalidBirthDateFormat = errors.New("provided invalid birth date format")
ErrTokenExpired = errors.New("token is expired")
ErrFailedToSign = errors.New("failed to sign jwt")
)
@@ -0,0 +1,26 @@
package jwtprovider
import (
"net/http"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
type Provider interface {
Parse(token *dto.Token) (*dto.UserDataInToken, error)
CreateRefreshAndAccessTokensForUser(userID uuid.UUID, role role.Role) (*dto.Tokens, error)
ParseVerified(token *dto.Token) (*dto.UserDataInToken, error)
ParseUnverified(token *dto.Token) (*dto.UserDataInToken, error)
ValidateUserDataInToken(u *dto.UserDataInToken) error
}
type Cookie interface {
Enabled() bool
Set(w http.ResponseWriter, tokens *dto.Tokens)
Clear(w http.ResponseWriter)
AccessToken(r *http.Request) *dto.AccessToken
RefreshToken(r *http.Request) *dto.RefreshToken
}
@@ -0,0 +1,199 @@
package jwtprovider
import (
"fmt"
"net/http"
"strconv"
"time"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/dto"
)
type manager struct {
enabled bool
cookieFabric *CookieBuilderFabric
prv Provider
}
func NewCookieManager(cfg *config.Config, provider Provider) Cookie {
m := &manager{
//enabled: cfg.Cookies.Enabled,
//cookieFabric: newCookieBuilder(
// cfg.Cookies.Domain,
// cfg.Cookies.Path,
// cfg.Cookies.Secure,
// cfg.Cookies.SameSite,
//),
prv: provider,
}
if !m.enabled {
return m
}
if err := m.cookieFabric.
Builder().
AccessName().
Value("test").
HTTPOnly().
MaxAge(0).
Build().
Valid(); err != nil {
panic(fmt.Errorf("cookie validation failed: %w", err))
}
return m
}
func (m *manager) Enabled() bool {
return m.enabled
}
func (m *manager) Set(w http.ResponseWriter, tokens *dto.Tokens) {
if !m.enabled || tokens == nil {
return
}
if tokens.AccessToken.Payload != "" {
m.setAccess(tokens.AccessToken, w)
}
if tokens.RefreshToken.Payload != "" {
m.setRefresh(tokens.RefreshToken, w)
}
}
func (m *manager) Clear(w http.ResponseWriter) {
if !m.enabled {
return
}
for _, name := range []string{accessTokenCookieKey, refreshTokenCookieKey, expiresAtCookieKey} {
b := m.cookieFabric.
Builder().
MaxAge(-1)
switch name {
case expiresAtCookieKey:
b.ExpiresName()
case refreshTokenCookieKey:
b.RefreshName().
HTTPOnly()
case accessTokenCookieKey:
b.AccessName().
HTTPOnly()
}
http.SetCookie(w, b.Build())
}
}
func (m *manager) AccessToken(r *http.Request) *dto.AccessToken {
if !m.enabled {
return nil
}
c, err := r.Cookie(accessTokenCookieKey)
if err != nil {
return nil
}
return &dto.AccessToken{
Payload: c.Value,
}
}
func (m *manager) RefreshToken(r *http.Request) *dto.RefreshToken {
if !m.enabled {
return nil
}
c, err := r.Cookie(refreshTokenCookieKey)
if err != nil {
return nil
}
return &dto.RefreshToken{
Payload: c.Value,
}
}
func (m *manager) setAccess(token dto.AccessToken, w http.ResponseWriter) {
accessTTL := m.tokenTTL(token.Token())
if accessTTL < 0 {
http.SetCookie(w, m.cookieFabric.
Builder().
AccessName().
HTTPOnly().
MaxAge(-1).
Build(),
)
http.SetCookie(w, m.cookieFabric.
Builder().
ExpiresName().
MaxAge(-1).
Build(),
)
} else if tokenExpiresAt := m.tokenExpiry(token.Token()); !tokenExpiresAt.IsZero() {
http.SetCookie(w, m.cookieFabric.
Builder().
AccessName().
Value(token.Payload).
HTTPOnly().
MaxAge(accessTTL).
Build(),
)
http.SetCookie(w, m.cookieFabric.
Builder().
ExpiresName().
Value(strconv.FormatInt(tokenExpiresAt.Unix(), 10)).
MaxAge(accessTTL).
Build(),
)
}
}
func (m *manager) setRefresh(token dto.RefreshToken, w http.ResponseWriter) {
refreshTTL := m.tokenTTL(token.Token())
if refreshTTL < 0 {
http.SetCookie(w, m.cookieFabric.
Builder().
RefreshName().
HTTPOnly().
MaxAge(-1).
Build(),
)
} else {
http.SetCookie(w, m.cookieFabric.
Builder().
RefreshName().
Value(token.Payload).
HTTPOnly().
MaxAge(refreshTTL).
Build(),
)
}
}
func (m *manager) tokenTTL(token *dto.Token) int {
expiresAt := m.tokenExpiry(token)
if expiresAt.IsZero() {
return -1
}
ttl := int(time.Until(expiresAt).Seconds())
if ttl <= 0 {
return -1
}
return ttl
}
func (m *manager) tokenExpiry(token *dto.Token) time.Time {
data, err := m.prv.ParseUnverified(token)
if err != nil {
return time.Time{}
}
return data.ExpiresAt
}
@@ -0,0 +1,187 @@
package jwtprovider
import (
"crypto/rand"
"crypto/rsa"
"encoding/base64"
"fmt"
"log/slog"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/environment"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var (
_ Provider = (*provider)(nil)
)
type provider struct {
accessLifetime time.Duration
refreshLifetime time.Duration
publicKey *rsa.PublicKey
privateKey *rsa.PrivateKey
parseFunc claimsParseFunc
}
func New(cfg *config.Config) Provider {
p := provider{
accessLifetime: cfg.JWT.AccessTokenLifetime,
refreshLifetime: cfg.JWT.RefreshTokenLifetime,
}
p.parseFunc = p.parseClaimsFromProtectedJWT
if cfg.Application.Environment == environment.ApplicationEnvironmentDev {
p.parseFunc = p.parseClaimsFromExposedJWT
}
var err error
if p.publicKey, err = readPublicKeyFromFile(cfg.JWT.PublicKeyPath); err != nil {
slog.Error("failed to read public key", "error", err)
panic(fmt.Errorf("failed to read public key: %w", err))
}
if p.privateKey, err = readPrivateKeyFromFile(cfg.JWT.PrivateKeyPath); err != nil {
slog.Error("failed to read private key", "error", err)
panic(fmt.Errorf("failed to read private key: %w", err))
}
return &p
}
func (p *provider) Parse(token *dto.Token) (*dto.UserDataInToken, error) {
claims, err := p.parseFunc(token)
if err != nil {
return nil, err
}
return claims.userData()
}
func (p *provider) ParseUnverified(t *dto.Token) (*dto.UserDataInToken, error) {
if t == nil {
return nil, ErrTokenIsMissing
}
claims, err := p.parseClaimsFromExposedJWT(t)
if err != nil {
return nil, err
}
return claims.userData()
}
func (p *provider) ParseVerified(t *dto.Token) (*dto.UserDataInToken, error) {
if t == nil {
return nil, ErrTokenIsMissing
}
claims, err := p.parseClaimsFromProtectedJWT(t)
if err != nil {
return nil, fmt.Errorf("failed to parse token: %w", err)
}
return claims.userData()
}
func (p *provider) CreateAccessTokenForUser(userID uuid.UUID, role role.Role) (*dto.AccessToken, error) {
t, err := p.createTokenForUser(userID, true, role)
if err != nil {
return nil, err
}
return &dto.AccessToken{
Payload: t.Payload,
}, nil
}
func (p *provider) CreateRefreshTokenForUser(userID uuid.UUID, role role.Role) (*dto.RefreshToken, error) {
t, err := p.createTokenForUser(userID, false, role)
if err != nil {
return nil, err
}
return &dto.RefreshToken{
Payload: t.Payload,
}, nil
}
func (p *provider) CreateRefreshAndAccessTokensForUser(userID uuid.UUID, role role.Role) (*dto.Tokens, error) {
access, err := p.CreateAccessTokenForUser(userID, role)
if err != nil {
return nil, err
}
refresh, err := p.CreateRefreshTokenForUser(userID, role)
if err != nil {
return nil, err
}
return &dto.Tokens{
AccessToken: *access,
RefreshToken: *refresh,
}, nil
}
func (p *provider) createTokenForUser(userID uuid.UUID, isAccess bool, role role.Role) (*dto.Token, error) {
now := time.Now()
var tokenExpiresAt time.Time
if isAccess {
tokenExpiresAt = now.Add(p.accessLifetime)
} else {
tokenExpiresAt = now.Add(p.refreshLifetime)
}
var nonce [32]byte
if _, err := rand.Read(nonce[:]); err != nil {
return nil, fmt.Errorf("generate token nonce: %w", err)
}
claims := &jwtClaims{
Nonce: base64.RawURLEncoding.EncodeToString(nonce[:]),
RegisteredClaims: jwt.RegisteredClaims{
Subject: userID.String(),
ExpiresAt: jwt.NewNumericDate(tokenExpiresAt),
NotBefore: jwt.NewNumericDate(now),
IssuedAt: jwt.NewNumericDate(now),
ID: uuid.NewString(),
},
IsAccess: isAccess,
Role: role,
}
t := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
payload, err := t.SignedString(p.privateKey)
if err != nil {
slog.Error("failed to sign jwt", "error", err)
return nil, ErrFailedToSign
}
return &dto.Token{Payload: payload}, nil
}
// TODO refactor maybe delete
func (p *provider) ValidateUserDataInToken(u *dto.UserDataInToken) error {
if u == nil {
return ErrInvalidUserDataInToken
}
switch {
case u.TokenID == uuid.Nil:
return fmt.Errorf("%w: unexpected nil token id", ErrInvalidUserDataInToken)
case u.UserID == uuid.Nil:
return fmt.Errorf("%w: unexpected nil user id", ErrInvalidUserDataInToken)
case u.IssuedAt.IsZero():
return fmt.Errorf("%w: unexpected zero issued at", ErrInvalidUserDataInToken)
case u.Email != nil && *u.Email == "":
return fmt.Errorf("%w: unexpected empty email", ErrInvalidUserDataInToken)
case u.PhoneNumber != nil && *u.PhoneNumber == "":
return fmt.Errorf("%w: unexpected empty phone number", ErrInvalidUserDataInToken)
case u.ExpiresAt.IsZero():
return fmt.Errorf("%w: unexpected zero expires at", ErrInvalidUserDataInToken)
}
return nil
}
func (p *provider) readKeyFunc(token *jwt.Token) (interface{}, error) {
if token.Method != jwt.SigningMethodRS256 {
return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
}
return p.publicKey, nil
}
@@ -0,0 +1,35 @@
package jwtprovider
import (
"crypto/rsa"
"fmt"
"os"
"github.com/golang-jwt/jwt/v5"
)
func readPrivateKeyFromFile(path string) (*rsa.PrivateKey, error) {
key, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read public key: %w", err)
}
privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(key)
if err != nil {
return nil, fmt.Errorf("failed to parse private key: %w", err)
}
return privateKey, nil
}
func readPublicKeyFromFile(path string) (*rsa.PublicKey, error) {
key, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read public key: %w", err)
}
privateKey, err := jwt.ParseRSAPublicKeyFromPEM(key)
if err != nil {
return nil, fmt.Errorf("failed to parse private key: %w", err)
}
return privateKey, nil
}
+43
View File
@@ -0,0 +1,43 @@
package cache
import (
"context"
"time"
"github.com/redis/go-redis/v9"
"gitea.privcloud.tech/mtusi2026/internal/config"
)
const defaultRedisPort = 6379
// OperationTimeout bounds each optional cache operation independently of the request.
const OperationTimeout = 300 * time.Millisecond
type Client struct {
*redis.Client
}
func New(cfg *config.Config) *Client {
if cfg.Redis.Port == 0 {
cfg.Redis.Port = defaultRedisPort
}
return &Client{
Client: redis.NewClient(cfg.Redis.BuildRedisOptions()),
}
}
func (c *Client) Ping(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, OperationTimeout)
defer cancel()
return c.Client.Ping(ctx).Err()
}
func (c *Client) Start(ctx context.Context) error {
return c.Ping(ctx)
}
func (c *Client) Stop(_ context.Context) error {
return c.Client.Close()
}
@@ -0,0 +1,71 @@
package encrypting
import (
"context"
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argon2idMemory = 64 * 1024 // KiB
argon2idTime = 3
argon2idThreads = 4
argon2idSaltLen = 16
argon2idKeyLen = 32
// Only this bounded profile is accepted; stored parameters cannot request arbitrary resources.
argon2idPrefix = "$argon2id$v=19$m=65536,t=3,p=4$"
)
func (e *encryptor) EncryptSecretUsingArgon2id(ctx context.Context, secret string) (string, error) {
if err := ctx.Err(); err != nil {
return "", err
}
var salt [argon2idSaltLen]byte
if _, err := rand.Read(salt[:]); err != nil {
return "", fmt.Errorf("%w: %w", ErrFailedToEncryptPassword, err)
}
key := argon2.IDKey([]byte(secret), salt[:], argon2idTime, argon2idMemory, argon2idThreads, argon2idKeyLen)
if err := ctx.Err(); err != nil {
return "", err
}
return argon2idPrefix + base64.RawStdEncoding.EncodeToString(salt[:]) + "$" + base64.RawStdEncoding.EncodeToString(key), nil
}
func (e *encryptor) CompareHashAndSecretUsingArgon2id(ctx context.Context, hash, secret string) error {
if err := ctx.Err(); err != nil {
return err
}
encoding := base64.RawStdEncoding.Strict()
if len(hash) != len(argon2idPrefix)+encoding.EncodedLen(argon2idSaltLen)+1+encoding.EncodedLen(argon2idKeyLen) {
return ErrFailedToComparePasswords
}
payload, ok := strings.CutPrefix(hash, argon2idPrefix)
if !ok {
return ErrFailedToComparePasswords
}
saltText, keyText, ok := strings.Cut(payload, "$")
if !ok {
return ErrFailedToComparePasswords
}
salt, err := encoding.DecodeString(saltText)
if err != nil || len(salt) != argon2idSaltLen {
return ErrFailedToComparePasswords
}
storedKey, err := encoding.DecodeString(keyText)
if err != nil || len(storedKey) != argon2idKeyLen {
return ErrFailedToComparePasswords
}
key := argon2.IDKey([]byte(secret), salt, argon2idTime, argon2idMemory, argon2idThreads, argon2idKeyLen)
if err = ctx.Err(); err != nil {
return err
}
if subtle.ConstantTimeCompare(storedKey, key) != 1 {
return ErrFailedToComparePasswords
}
return nil
}
@@ -0,0 +1,72 @@
package encrypting
import (
"context"
"crypto/sha256"
"crypto/subtle"
"encoding/hex"
"strings"
"golang.org/x/crypto/bcrypt"
)
type encryptor struct {
cost int
generateFromPasswordFunc func([]byte, int) ([]byte, error)
compareHashAndPasswordFunc func([]byte, []byte) error
}
func New() Encryptor {
return &encryptor{
cost: bcrypt.DefaultCost,
generateFromPasswordFunc: bcrypt.GenerateFromPassword,
compareHashAndPasswordFunc: bcrypt.CompareHashAndPassword,
}
}
func (e *encryptor) EncryptSecret(_ context.Context, secret string) (string, error) {
res, err := e.generateFromPasswordFunc([]byte(secret), e.cost)
if err != nil {
return "", ErrFailedToEncryptPassword
}
return string(res), nil
}
// EncryptSecretUsingSum256 hashes a high-entropy session token, not a password.
func (e *encryptor) EncryptSecretUsingSum256(ctx context.Context, secret string) (string, error) {
if err := ctx.Err(); err != nil {
return "", err
}
sum := sha256.Sum256([]byte(secret))
return "sha256:" + hex.EncodeToString(sum[:]), nil
}
func (e *encryptor) CompareHashAndSecret(_ context.Context, hash, password string) error {
err := e.compareHashAndPasswordFunc([]byte(hash), []byte(password))
if err != nil {
return ErrFailedToComparePasswords
}
return nil
}
func (e *encryptor) CompareHashAndSecretUsingSum256(ctx context.Context, hash, secret string) error {
if err := ctx.Err(); err != nil {
return err
}
sum := sha256.Sum256([]byte(secret))
if payload, ok := strings.CutPrefix(hash, "sha256:"); ok {
stored, err := hex.DecodeString(payload)
if err != nil || len(stored) != sha256.Size || subtle.ConstantTimeCompare(stored, sum[:]) != 1 {
return ErrFailedToComparePasswords
}
return nil
}
// Preserve existing lab2/lab3 sessions across a rolling deployment.
// Passwords continue to use Argon2id; only old random-token fingerprints use this fallback.
if strings.HasPrefix(hash, "$2") {
if err := e.compareHashAndPasswordFunc([]byte(hash), []byte(hex.EncodeToString(sum[:]))); err == nil {
return nil
}
}
return ErrFailedToComparePasswords
}
+8
View File
@@ -0,0 +1,8 @@
package encrypting
import "errors"
var (
ErrFailedToEncryptPassword = errors.New("failed to encrypt password")
ErrFailedToComparePasswords = errors.New("failed to compare passwords")
)
@@ -0,0 +1,12 @@
package encrypting
import "context"
type Encryptor interface {
EncryptSecretUsingArgon2id(ctx context.Context, secret string) (string, error)
CompareHashAndSecretUsingArgon2id(ctx context.Context, hash, secret string) error
EncryptSecret(ctx context.Context, secret string) (string, error)
EncryptSecretUsingSum256(_ context.Context, secret string) (string, error)
CompareHashAndSecret(ctx context.Context, hash, secret string) error
CompareHashAndSecretUsingSum256(ctx context.Context, hash, secret string) error
}
@@ -0,0 +1,43 @@
package encrypting
import (
"context"
"crypto/sha256"
"encoding/hex"
"golang.org/x/crypto/bcrypt"
"testing"
)
func TestSessionFingerprints(t *testing.T) {
e := New()
ctx := context.Background()
token := "synthetic-high-entropy-session-value"
hash, err := e.EncryptSecretUsingSum256(ctx, token)
if err != nil {
t.Fatal(err)
}
if err = e.CompareHashAndSecretUsingSum256(ctx, hash, token); err != nil {
t.Fatal(err)
}
for _, bad := range []string{"sha256:00", "sha256:invalid", "unknown"} {
if e.CompareHashAndSecretUsingSum256(ctx, bad, token) == nil {
t.Fatal("accepted malformed fingerprint")
}
}
if e.CompareHashAndSecretUsingSum256(ctx, hash, token+"x") == nil {
t.Fatal("accepted wrong token")
}
sum := sha256.Sum256([]byte(token))
legacy, err := bcrypt.GenerateFromPassword([]byte(hex.EncodeToString(sum[:])), bcrypt.MinCost)
if err != nil {
t.Fatal(err)
}
if err = e.CompareHashAndSecretUsingSum256(ctx, string(legacy), token); err != nil {
t.Fatal("legacy session rejected", err)
}
canceled, cancel := context.WithCancel(ctx)
cancel()
if e.CompareHashAndSecretUsingSum256(canceled, hash, token) == nil {
t.Fatal("ignored cancellation")
}
}
+164
View File
@@ -0,0 +1,164 @@
package migrator
import (
"context"
"io/fs"
"log/slog"
"github.com/jackc/pgx/v5"
"github.com/jackc/tern/v2/migrate"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/migrations"
)
type Migrator interface {
MigrateUp(ctx context.Context) error
MigrateDown(ctx context.Context) error
MigrateTo(ctx context.Context, version int32) error
GetVersion(ctx context.Context) (int32, error)
Configure(ctx context.Context) error
Close(ctx context.Context) error
Start(ctx context.Context) error
Stop(ctx context.Context) error
}
type migrator struct {
cfg *config.Config
conn *pgx.Conn
migrator *migrate.Migrator
migrations fs.FS
configured bool
closed bool
}
func New(cfg *config.Config) Migrator {
return &migrator{
cfg: cfg,
conn: nil,
migrator: nil,
migrations: migrations.Migrations,
configured: false,
closed: false,
}
}
func (m *migrator) MigrateUp(ctx context.Context) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.Migrate(ctx)
}
func (m *migrator) MigrateDown(ctx context.Context) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.MigrateTo(ctx, 0)
}
func (m *migrator) MigrateTo(ctx context.Context, version int32) error {
if !m.configured {
return apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.MigrateTo(ctx, version)
}
func (m *migrator) GetVersion(ctx context.Context) (int32, error) {
if !m.configured {
return -1, apperr.New(apperr.CodeInternal, "migrator was not configured")
}
return m.migrator.GetCurrentVersion(ctx)
}
func (m *migrator) Configure(ctx context.Context) error {
if err := m.initConn(ctx); err != nil {
return err
}
if err := m.initMigrator(ctx); err != nil {
return err
}
if err := m.loadMigrations(); err != nil {
return err
}
m.configured = true
return nil
}
func (m *migrator) Close(ctx context.Context) error {
if m.conn == nil || m.closed {
return nil
}
if err := m.closeConn(ctx); err != nil {
return err
}
m.closed = true
return nil
}
func (m *migrator) Start(ctx context.Context) error {
if !m.cfg.Postgres.GetRunMigrations() {
slog.Info("flag run migrations is disabled: skipping migrating")
return nil
}
err := m.Configure(ctx)
if err != nil {
slog.Error("failed to configure migrator", "error", err)
return err
}
err = m.MigrateUp(ctx)
if err != nil {
slog.Error("failed to migrate database up", "error", err)
return err
}
if err = m.Close(ctx); err != nil {
slog.Error("failed close connection to database", "error", err)
return err
}
m.closed = true
return nil
}
func (m *migrator) Stop(ctx context.Context) error {
return m.Close(ctx)
}
func (m *migrator) loadMigrations() (err error) {
err = m.migrator.LoadMigrations(m.migrations)
if err != nil {
slog.Error("failed to load migrations", "error", err)
return apperr.New(apperr.CodeInternal, "failed to load migrations")
}
slog.Info("successfully loaded migrations", "error", err)
return nil
}
func (m *migrator) initConn(ctx context.Context) (err error) {
m.closed = false
m.conn, err = pgx.Connect(ctx, m.cfg.Postgres.GetURI())
if err != nil {
slog.Error("failed to create connection to database", "error", err)
return apperr.New(apperr.CodeInternal, "failed to create connection to database")
}
slog.Info("connected to database", "db", m.cfg.Postgres.Database)
return nil
}
func (m *migrator) initMigrator(ctx context.Context) (err error) {
m.migrator, err = migrate.NewMigrator(ctx, m.conn, m.cfg.Postgres.GetVersionTableName())
if err != nil {
slog.Error("failed to initialize migrator", "error", err)
return apperr.New(apperr.CodeInternal, "failed to initialize migrator")
}
slog.Info("successfully initialized migrator")
return nil
}
func (m *migrator) closeConn(ctx context.Context) error {
return m.conn.Close(ctx)
}
+69
View File
@@ -0,0 +1,69 @@
package objectstore
import (
"context"
"errors"
"io"
"net/http"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/smithy-go"
"gitea.privcloud.tech/mtusi2026/internal/config"
)
type Store struct {
Client *s3.Client
Bucket string
}
func New(c *config.Attachment) *Store {
return &Store{
Bucket: c.Bucket,
Client: s3.New(
s3.Options{
Region: c.Region,
BaseEndpoint: aws.String(c.Endpoint),
UsePathStyle: true,
Credentials: credentials.NewStaticCredentialsProvider(
c.AccessKey,
c.SecretKey,
"",
),
RetryMaxAttempts: 1,
HTTPClient: &http.Client{Timeout: 30 * time.Second},
},
),
}
}
func (s *Store) Put(ctx context.Context, key, mime string, r io.Reader, size int64) error {
_, err := s.Client.PutObject(ctx, &s3.PutObjectInput{Bucket: &s.Bucket, Key: &key, Body: r, ContentLength: &size, ContentType: &mime})
return err
}
func (s *Store) Get(ctx context.Context, key string) (*s3.GetObjectOutput, error) {
return s.Client.GetObject(ctx, &s3.GetObjectInput{Bucket: &s.Bucket, Key: &key})
}
func (s *Store) Head(ctx context.Context, key string) (*s3.HeadObjectOutput, error) {
return s.Client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: &s.Bucket, Key: &key})
}
func (s *Store) Delete(ctx context.Context, key string) error {
_, e := s.Client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: &s.Bucket, Key: &key})
return e
}
func (s *Store) Ping(ctx context.Context) error {
_, e := s.Client.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: &s.Bucket})
return e
}
func Missing(err error) bool {
var api smithy.APIError
return errors.As(err, &api) && (api.ErrorCode() == "NoSuchKey" || api.ErrorCode() == "NotFound" || api.ErrorCode() == "404")
}
@@ -0,0 +1,25 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5"
pgxUUID "github.com/vgarvardt/pgx-google-uuid/v5"
)
type AfterConnect func(ctx context.Context, conn *pgx.Conn) error
func AddUUIDSupport(_ context.Context, conn *pgx.Conn) error {
pgxUUID.Register(conn.TypeMap())
return nil
}
func WithEnumTypeSupport(enumName string) AfterConnect {
return func(ctx context.Context, conn *pgx.Conn) error {
dt, err := conn.LoadType(ctx, enumName)
if err != nil {
return err
}
conn.TypeMap().RegisterType(dt)
return nil
}
}
+7
View File
@@ -0,0 +1,7 @@
package postgres
type MigrationConfig interface {
GetURI() string
GetVersionTableName() string
GetRunMigrations() bool
}
+10
View File
@@ -0,0 +1,10 @@
package postgres
import (
"errors"
)
var (
errCreatingPool = errors.New("failed to create postgres pool")
errParseConfig = errors.New("failed to parse postgres config")
)
@@ -0,0 +1,15 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
type Conn interface {
SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults
Exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error)
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
}
+95
View File
@@ -0,0 +1,95 @@
package postgres
import (
"context"
"log/slog"
"strconv"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/tracelog"
pgxslog "github.com/mcosta74/pgx-slog"
)
type ConfigWithLog interface {
GetLogLevel() string
}
type ConfigWithTimeouts interface {
GetConnectTimeout() time.Duration
GetQueryTimeout() time.Duration
}
type ConfigWithMaxConn interface {
GetMaxConnections() int32
}
func getLevelFromConfig(cfg MigrationConfig) tracelog.LogLevel {
if logCfg, ok := cfg.(ConfigWithLog); ok {
lvl, _ := tracelog.LogLevelFromString(logCfg.GetLogLevel())
return lvl
}
return tracelog.LogLevelError
}
func addMaxConnectionsToCfg(cfg any, poolCfg *pgxpool.Config) {
if connCfg, ok := cfg.(ConfigWithMaxConn); ok {
poolCfg.MaxConns = connCfg.GetMaxConnections()
}
}
func New(cfg MigrationConfig, afterConnect ...AfterConnect) *pgxpool.Pool {
lvl := getLevelFromConfig(cfg)
if len(afterConnect) == 0 {
afterConnect = []AfterConnect{AddUUIDSupport}
}
poolConfig, err := pgxpool.ParseConfig(cfg.GetURI())
if err != nil {
slog.Error("failed to parse postgres config", "error", err)
panic(err)
}
addMaxConnectionsToCfg(cfg, poolConfig)
if timeoutCfg, ok := cfg.(ConfigWithTimeouts); ok {
poolConfig.ConnConfig.ConnectTimeout = timeoutCfg.GetConnectTimeout()
poolConfig.ConnConfig.RuntimeParams["statement_timeout"] = strconv.FormatInt(timeoutCfg.GetQueryTimeout().Milliseconds(), 10)
}
poolConfig.ConnConfig.RuntimeParams["application_name"] = "mtusi-api"
slog.Info("postgres_pool_config", "max_conns", poolConfig.MaxConns,
"connect_timeout", poolConfig.ConnConfig.ConnectTimeout,
"statement_timeout_ms", poolConfig.ConnConfig.RuntimeParams["statement_timeout"])
poolConfig.ConnConfig.Tracer = &tracelog.TraceLog{
Logger: pgxslog.NewLogger(slog.Default()),
LogLevel: lvl,
Config: &tracelog.TraceLogConfig{
TimeKey: "ts",
},
}
poolConfig.AfterConnect = load(afterConnect...)
pool, err := pgxpool.NewWithConfig(context.Background(), poolConfig)
if err != nil {
slog.Error("failed to create postgres pool", "error", err)
panic(err)
}
slog.Info("successfully connected to postgres pool")
return pool
}
func load(afterConnects ...AfterConnect) func(ctx context.Context, conn *pgx.Conn) error {
return func(ctx context.Context, conn *pgx.Conn) error {
for _, afterConnect := range afterConnects {
if err := afterConnect(ctx, conn); err != nil {
return err
}
}
return nil
}
}
@@ -0,0 +1,59 @@
package txmanager
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
type TransactionManager struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *TransactionManager {
return &TransactionManager{
pool: pool,
}
}
func (tm *TransactionManager) RunInTransaction(ctx context.Context, opts *pgx.TxOptions, fn func(tx pgx.Tx) error) (err error) {
var tx pgx.Tx
if opts != nil {
tx, err = tm.pool.BeginTx(ctx, *opts)
} else {
tx, err = tm.pool.Begin(ctx)
}
if err != nil {
return fmt.Errorf("failed to begin transaction: %w", err)
}
var committed bool
defer func() {
if p := recover(); p != nil {
err = fmt.Errorf("panic in transaction: %v", p)
}
if !committed {
rollbackErr := tx.Rollback(ctx)
if rollbackErr != nil && !errors.Is(rollbackErr, pgx.ErrTxClosed) {
slog.Error("failed to rollback transaction", "error", rollbackErr)
}
}
}()
if err = fn(tx); err != nil {
return fmt.Errorf("failed to execute transaction: %w", err)
}
if err = tx.Commit(ctx); err != nil {
return fmt.Errorf("failed to commit transaction: %w", err)
}
committed = true
return nil
}
@@ -0,0 +1,257 @@
package framework
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"mime"
"net/http"
"strconv"
"strings"
"github.com/go-chi/chi/v5"
v10 "github.com/go-playground/validator/v10"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
)
func validate(ctx context.Context, v *validator.ValidatorImpl, value any) error {
err := v.ValidateCtx(ctx, value)
if err == nil {
return nil
}
var fieldErrors v10.ValidationErrors
if errors.As(err, &fieldErrors) {
return apperr.Wrap(err, apperr.CodeValidation, "invalid request fields")
}
return apperr.Wrap(err, apperr.CodeInternal, "validation failed")
}
func Validate(w http.ResponseWriter, r *http.Request, v *validator.ValidatorImpl, value any) bool {
if err := validate(r.Context(), v, value); err != nil {
JSONError(r.Context(), w, err)
return false
}
return true
}
func JSONResponse(w http.ResponseWriter, status int, body any) {
w.Header().Set(headers.HeaderContentType, "application/json")
w.WriteHeader(status)
if status == http.StatusNoContent {
return
}
if err := json.NewEncoder(w).Encode(body); err != nil {
wrapped := apperr.Wrap(err, apperr.CodeInternal, "failed json encode")
slog.Error("response", "error", wrapped)
}
}
func JSONError(ctx context.Context, w http.ResponseWriter, err error) {
if err == nil {
return
}
requestId, ok := ctx.Value(headers.HeaderRequestID).(uuid.UUID)
if !ok {
requestId = uuid.New()
}
w.Header().Set(headers.HeaderRequestID, requestId.String())
if errors.Is(err, context.DeadlineExceeded) {
err = apperr.Wrap(err, apperr.CodeServiceUnavailable, "request deadline exceeded")
}
appErr := apperr.As(err)
if appErr == nil {
appErr = apperr.As(apperr.New(apperr.CodeInternal, "internal server error"))
}
if appErr.Code().HTTPStatus() == http.StatusUnauthorized && w.Header().Get("WWW-Authenticate") == "" {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
slog.Error("response", "error", err, "status", appErr.Code().HTTPStatus(), "requestId", requestId.String())
var code contracts.ErrorErrorCode
switch appErr.Code() {
case apperr.CodeBadRequest, apperr.CodeValidation:
code = contracts.InvalidRequest
case apperr.CodeUnauthorized:
code = contracts.Unauthorized
case apperr.CodeNotFound:
code = contracts.NotFound
case apperr.CodeAlreadyExists, apperr.CodeConflict:
code = contracts.Conflict
case apperr.CodePayloadTooLarge:
code = contracts.PayloadTooLarge
case apperr.CodeTooManyRequests:
code = contracts.RateLimited
case apperr.CodeServiceUnavailable, apperr.CodeUnavailable:
code = contracts.Unavailable
case apperr.CodeUnsupportedMediaType:
code = contracts.UnsupportedMediaType
default:
code = contracts.InternalError
}
JSONResponse(w, appErr.Code().HTTPStatus(), contracts.Error{
Error: struct {
Code contracts.ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
}{
Code: code,
Message: appErr.Message(),
RequestId: requestId.String(),
},
})
}
func Decode(w http.ResponseWriter, r *http.Request, object any) bool {
mediaType, params, err := mime.ParseMediaType(r.Header.Get(headers.HeaderContentType))
if err != nil || mediaType != "application/json" ||
(params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) {
JSONError(r.Context(), w, apperr.New(apperr.CodeUnsupportedMediaType, "expected application/json"))
return false
}
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(object); err != nil {
JSONError(r.Context(), w, apperr.Wrap(err, apperr.CodeBadRequest, "failed decode"))
return false
}
var trailing any
if err := decoder.Decode(&trailing); err != io.EOF {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "expected one JSON object"))
return false
}
return true
}
func PathParam(r *http.Request, key string) string {
return chi.URLParam(r, key)
}
func QueryParam(r *http.Request, key string) string {
return r.URL.Query().Get(key)
}
func HeaderParam(r *http.Request, key string) string {
return r.Header.Get(key)
}
func ParseIDFromPathParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := PathParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromQueryParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := QueryParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromHeaderParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := HeaderParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "missing or invalid user ID"))
return uuid.Nil, err
}
return id, nil
}
func Header(r *http.Request, header string) (string, bool) {
return r.Header.Get(header), r.Header.Get(header) != ""
}
func Token(r *http.Request) (string, bool) {
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return "", false
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return "", false
}
return token, true
}
type sessionContextKey struct{}
func WithVerifiedSession(r *http.Request, data *dto.UserDataInToken) *http.Request {
return r.WithContext(context.WithValue(r.Context(), sessionContextKey{}, *data))
}
func ParseToken(r *http.Request, provider jwtprovider.Provider) (*dto.UserDataInToken, error) {
if data, ok := r.Context().Value(sessionContextKey{}).(dto.UserDataInToken); ok {
return &data, nil
}
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "missing authorization header")
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid authorization header")
}
userData, err := provider.ParseVerified(&dto.Token{Payload: token})
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeUnauthorized, "invalid token")
}
return userData, nil
}
func PageParams(w http.ResponseWriter, r *http.Request) (*int, *uuid.UUID, bool) {
query := r.URL.Query()
var limit *int
if values, exists := query["limit"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
value, err := strconv.Atoi(values[0])
if err != nil || value < 1 || value > 100 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
limit = &value
}
var afterID *uuid.UUID
if values, exists := query["cursor"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
id, err := uuid.Parse(values[0])
if err != nil || id == uuid.Nil {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
afterID = &id
}
return limit, afterID, true
}
@@ -0,0 +1,8 @@
package headers
const (
HeaderContentType = "Content-Type"
HeaderRequestID = "X-Request-Id"
HeaderUserID = "X-User-Id"
HeaderAuthorization = "Authorization"
)
@@ -0,0 +1,75 @@
package middleware
import (
"context"
"net/http"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types/role"
)
var _ AuthMiddleware = (*authMiddleware)(nil)
type AuthMiddleware interface {
WithPrivateAccess(next http.Handler) http.Handler
WithAdminAccess(next http.Handler) http.Handler
}
type SessionVerifier interface {
VerifySession(ctx context.Context, token dto.Token) (*dto.UserDataInToken, error)
}
type authMiddleware struct {
verifier SessionVerifier
}
func NewAuthMiddleware(verifier SessionVerifier) AuthMiddleware {
return &authMiddleware{verifier: verifier}
}
func (a *authMiddleware) WithPrivateAccess(next http.Handler) http.Handler {
return a.privateAccessCheckCallback(next)
}
func (a *authMiddleware) WithAdminAccess(next http.Handler) http.Handler {
return a.operatorAccessCheckCallback(role.Admin, next)
}
func (a *authMiddleware) privateAccessCheckCallback(next http.Handler) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
data, err := a.verifySession(r)
if err != nil {
framework.JSONError(r.Context(), w, err)
return
}
next.ServeHTTP(w, framework.WithVerifiedSession(r, data))
}
}
func (a *authMiddleware) operatorAccessCheckCallback(expectedRole role.Role, next http.Handler) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
u, err := a.verifySession(r)
if err != nil {
framework.JSONError(r.Context(), w, err)
return
}
if u.Role != role.Admin && u.Role != expectedRole {
framework.JSONError(r.Context(), w, apperr.New(apperr.CodeForbidden, "insufficient permissions"))
return
}
next.ServeHTTP(w, framework.WithVerifiedSession(r, u))
}
}
func (a *authMiddleware) verifySession(r *http.Request) (*dto.UserDataInToken, error) {
token, found := framework.Token(r)
if !found || token == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "missing or invalid bearer token")
}
return a.verifier.VerifySession(r.Context(), dto.Token{Payload: token})
}
@@ -0,0 +1,73 @@
package middleware
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/framework"
"github.com/google/uuid"
)
type sessionVerifier struct {
calls int
data dto.UserDataInToken
err error
}
func (v *sessionVerifier) VerifySession(context.Context, dto.Token) (*dto.UserDataInToken, error) {
v.calls++
return &v.data, v.err
}
func TestVerifiedSessionIsRequestScoped(t *testing.T) {
verifier := &sessionVerifier{data: dto.UserDataInToken{UserID: uuid.New()}}
middleware := NewAuthMiddleware(verifier)
handled := 0
handler := middleware.WithPrivateAccess(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// A nil provider is intentional: the handler must use the verified request identity.
data, err := framework.ParseToken(r, nil)
if err != nil {
t.Fatal(err)
}
if data.UserID != verifier.data.UserID {
t.Fatal("verified identity changed")
}
handled++
w.WriteHeader(http.StatusNoContent)
}))
for range 2 {
request := httptest.NewRequest("GET", "/private", nil)
request.Header.Set("Authorization", "Bearer synthetic-token")
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, request)
if recorder.Code != 204 {
t.Fatal(recorder.Code)
}
}
if verifier.calls != 2 || handled != 2 {
t.Fatal("session verification must run for every request")
}
verifier.err = apperr.New(apperr.CodeUnauthorized, "revoked session")
request := httptest.NewRequest("GET", "/private", nil)
request.Header.Set("Authorization", "Bearer synthetic-token")
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, request)
if recorder.Code != 401 || handled != 2 {
t.Fatal("revocation was bypassed by cached request identity")
}
}
func TestMissingTokenDoesNotCallSessionStore(t *testing.T) {
verifier := &sessionVerifier{err: errors.New("must not be called")}
handler := NewAuthMiddleware(verifier).WithPrivateAccess(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { t.Fatal("handler called without a token") }))
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest("GET", "/private", nil))
if recorder.Code != 401 || verifier.calls != 0 {
t.Fatal("missing token was accepted")
}
}
@@ -0,0 +1,12 @@
package middleware
import "net/http"
func Instance(id string) Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", id)
next.ServeHTTP(w, r)
})
}
}
@@ -0,0 +1,34 @@
package middleware
import (
"log/slog"
"net/http"
"time"
"github.com/go-chi/chi/v5/middleware"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
)
func LoggingMiddleware() Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
started := time.Now()
wrapped := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
next.ServeHTTP(wrapped, r)
status := wrapped.Status()
if status == 0 {
status = http.StatusOK
}
slog.InfoContext(r.Context(), "http request",
"method", r.Method,
"path", r.URL.Path,
"status", status,
"duration", time.Since(started),
"bytes", wrapped.BytesWritten(),
"request_id", w.Header().Get(headers.HeaderRequestID),
)
})
}
}
@@ -0,0 +1,5 @@
package middleware
import "net/http"
type Middleware = func(http.Handler) http.Handler
@@ -0,0 +1,22 @@
package middleware
import (
"context"
"net/http"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
)
func RequestIDMiddleware() Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
requestID := uuid.New()
w.Header().Set(headers.HeaderRequestID, requestID.String())
ctx = context.WithValue(ctx, headers.HeaderRequestID, requestID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
@@ -0,0 +1,23 @@
package middleware
import (
"context"
"net/http"
"strings"
"time"
)
// RequestTimeout bounds database work and waiting for a pooled connection.
func RequestTimeout(timeout time.Duration, attachmentTimeout ...time.Duration) Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestTimeout := timeout
if len(attachmentTimeout) > 0 && strings.Contains(r.URL.Path, "/attachments") {
requestTimeout = attachmentTimeout[0]
}
ctx, cancel := context.WithTimeout(r.Context(), requestTimeout)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
+131
View File
@@ -0,0 +1,131 @@
package router
import (
"net/http"
"github.com/go-chi/chi/v5"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/middleware"
)
type Router interface {
Private(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
Public(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
Admin(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler)
ServeHTTP(w http.ResponseWriter, r *http.Request)
With(mw ...func(http.Handler) http.Handler) Router
Use(mw ...func(http.Handler) http.Handler) Router
Handle(pattern string, handler http.Handler)
Get(pattern string, handler http.HandlerFunc)
Head(pattern string, handler http.HandlerFunc)
Options(pattern string, handler http.HandlerFunc)
Post(pattern string, handler http.HandlerFunc)
Put(pattern string, handler http.HandlerFunc)
Patch(pattern string, handler http.HandlerFunc)
Delete(pattern string, handler http.HandlerFunc)
Connect(pattern string, handler http.HandlerFunc)
Trace(pattern string, handler http.HandlerFunc)
}
type router struct {
r chi.Router
jwtMw middleware.AuthMiddleware
}
func New(jwtMw middleware.AuthMiddleware, mw ...middleware.Middleware) Router {
r := chi.NewRouter()
r.Use(mw...)
return &router{
r: r,
jwtMw: jwtMw,
}
}
func (c *router) Group(pattern string) Router {
sub := &router{
r: chi.NewRouter(),
jwtMw: c.jwtMw,
}
c.r.Mount(pattern, sub.r)
return sub
}
func (c *router) Public(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, next.ServeHTTP)
}
func (c *router) Private(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, (c.jwtMw.WithPrivateAccess(next)).ServeHTTP)
}
func (c *router) Admin(method, pattern string, handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) {
next := c.applyMiddlewares(handler, mw...)
c.r.MethodFunc(method, pattern, (c.jwtMw.WithAdminAccess(next)).ServeHTTP)
}
func (c *router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
c.r.ServeHTTP(w, r)
}
func (c *router) With(mw ...func(http.Handler) http.Handler) Router {
sub := &router{
r: c.r.With(mw...),
jwtMw: c.jwtMw,
}
return sub
}
func (c *router) Use(mw ...func(http.Handler) http.Handler) Router {
c.r.Use(mw...)
return c
}
func (c *router) Handle(pattern string, handler http.Handler) {
c.r.Handle(pattern, handler)
}
func (c *router) Get(pattern string, handler http.HandlerFunc) {
c.r.Get(pattern, handler)
}
func (c *router) Head(pattern string, handler http.HandlerFunc) {
c.r.Head(pattern, handler)
}
func (c *router) Options(pattern string, handler http.HandlerFunc) {
c.r.Options(pattern, handler)
}
func (c *router) Post(pattern string, handler http.HandlerFunc) {
c.r.Post(pattern, handler)
}
func (c *router) Put(pattern string, handler http.HandlerFunc) {
c.r.Put(pattern, handler)
}
func (c *router) Patch(pattern string, handler http.HandlerFunc) {
c.r.Patch(pattern, handler)
}
func (c *router) Delete(pattern string, handler http.HandlerFunc) {
c.r.Delete(pattern, handler)
}
func (c *router) Connect(pattern string, handler http.HandlerFunc) {
c.r.Connect(pattern, handler)
}
func (c *router) Trace(pattern string, handler http.HandlerFunc) {
c.r.Trace(pattern, handler)
}
func (c *router) applyMiddlewares(handler http.HandlerFunc, mw ...func(http.Handler) http.Handler) http.Handler {
next := http.Handler(handler)
for _, mwFunc := range mw {
next = mwFunc(next)
}
return next
}
@@ -0,0 +1,82 @@
package authprovider
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type Type string
const (
TypeUndefined Type = "undefined"
TypePassword Type = "password"
TypeEmail Type = "email"
TypePhone Type = "phone"
TypeGoogle Type = "google"
TypeTelegram Type = "telegram"
)
var allowedTypes = map[Type]struct{}{
TypePassword: {},
TypeEmail: {},
TypePhone: {},
TypeGoogle: {},
TypeTelegram: {},
}
func ParseType(value string) Type {
t := Type(strings.ToLower(value))
if !t.IsValid() {
return TypeUndefined
}
return t
}
func ParseAndValidateType(value string) (Type, error) {
parsed := ParseType(value)
if _, ok := allowedTypes[parsed]; ok {
return parsed, nil
}
return TypeUndefined, types.ErrUnsupportedOTPStatus
}
func (t Type) String() string {
return string(t)
}
func (t Type) Validate() error {
if _, ok := allowedTypes[t]; ok {
return nil
}
return types.ErrUnsupportedAuthProviderType
}
func (t Type) IsValid() bool {
_, ok := allowedTypes[t]
return ok
}
func (t Type) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *Type) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalAuthProviderTypeIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseType(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
@@ -0,0 +1,77 @@
package environment
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type ApplicationEnvironment string
const (
ApplicationEnvironmentUndefined ApplicationEnvironment = "undefined"
ApplicationEnvironmentDev ApplicationEnvironment = "dev"
ApplicationEnvironmentProd ApplicationEnvironment = "prod"
)
var allowedEnvironments = map[ApplicationEnvironment]struct{}{
ApplicationEnvironmentUndefined: {},
ApplicationEnvironmentDev: {},
ApplicationEnvironmentProd: {},
}
func ParseEnvironment(value string) ApplicationEnvironment {
s := ApplicationEnvironment(strings.ToLower(value))
if !s.IsValid() {
return ApplicationEnvironmentUndefined
}
return s
}
func ParseAndValidateEnvironment(status string) (ApplicationEnvironment, error) {
parsed := ParseEnvironment(status)
if _, ok := allowedEnvironments[parsed]; ok {
return parsed, nil
}
return ApplicationEnvironmentUndefined, types.ErrUnsupportedApplicationEnvironment
}
func (t ApplicationEnvironment) String() string {
return string(t)
}
func (t ApplicationEnvironment) Validate() error {
if _, ok := allowedEnvironments[t]; ok {
return nil
}
return types.ErrUnsupportedApplicationEnvironment
}
func (t ApplicationEnvironment) IsValid() bool {
_, ok := allowedEnvironments[t]
return ok
}
func (t ApplicationEnvironment) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *ApplicationEnvironment) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalApplicationEnvironmentIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseEnvironment(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
+25
View File
@@ -0,0 +1,25 @@
package types
import "errors"
var (
ErrUnsupportedRole = errors.New("unsupported role")
ErrUnsupportedOTPType = errors.New("unsupported OTP type")
ErrUnsupportedAuthProviderType = errors.New("unsupported auth provider type")
ErrUnsupportedContactType = errors.New("unsupported contact type")
ErrUnsupportedOTPStatus = errors.New("unsupported OTP status")
ErrUnsupportedOTPResult = errors.New("unsupported OTP result")
ErrUnsupportedFormStatus = errors.New("unsupported form status")
ErrUnsupportedAuthIdentityStatus = errors.New("unsupported auth identity status")
ErrUnsupportedApplicationEnvironment = errors.New("unsupported application environment")
ErrUnmarshalRoleIntoNilPointer = errors.New("unmarshal role into nil pointer")
ErrUnmarshalOTPTypeIntoNilPointer = errors.New("unmarshal OTP type into nil pointer")
ErrUnmarshalAuthProviderTypeIntoNilPointer = errors.New("unmarshal auth provider into nil pointer")
ErrUnmarshalContactTypeIntoNilPointer = errors.New("unmarshal contact into nil pointer")
ErrUnmarshalOTPStatusIntoNilPointer = errors.New("unmarshal OTP status into nil pointer")
ErrUnmarshalOTPResultIntoNilPointer = errors.New("unmarshal OTP result into nil pointer")
ErrUnmarshalFormStatusIntoNilPointer = errors.New("unmarshal form status into nil pointer")
ErrUnmarshalAuthIdentityStatusIntoNilPointer = errors.New("unmarshal auth identity status into nil pointer")
ErrUnmarshalApplicationEnvironmentIntoNilPointer = errors.New("unmarshal application environment into nil pointer")
)
+105
View File
@@ -0,0 +1,105 @@
package role
import (
"encoding/json"
"strings"
"gitea.privcloud.tech/mtusi2026/internal/pkg/types"
)
type Role string
const (
Undefined Role = "undefined"
User Role = "user"
Doctor Role = "doctor"
Manager Role = "manager"
Admin Role = "admin"
)
var allowedRoles = map[Role]struct{}{
User: {},
Doctor: {},
Manager: {},
Admin: {},
}
func ParseRole(s string) Role {
r := Role(strings.ToLower(s))
if !r.IsValid() {
return Undefined
}
return r
}
func ParseAndValidateRole(s string) (Role, error) {
parsed := ParseRole(s)
if _, ok := allowedRoles[parsed]; ok {
return parsed, nil
}
return Undefined, types.ErrUnsupportedRole
}
func (t Role) String() string {
return string(t)
}
func (t Role) Validate() error {
if _, ok := allowedRoles[t]; ok {
return nil
}
return types.ErrUnsupportedRole
}
func (t Role) IsValid() bool {
_, ok := allowedRoles[t]
return ok
}
func (t Role) MarshalJSON() ([]byte, error) {
if err := t.Validate(); err != nil {
return nil, err
}
return json.Marshal(t.String())
}
func (t *Role) UnmarshalJSON(data []byte) error {
if t == nil {
return types.ErrUnmarshalRoleIntoNilPointer
}
var value string
if err := json.Unmarshal(data, &value); err != nil {
return err
}
parsed := ParseRole(value)
if err := parsed.Validate(); err != nil {
return err
}
*t = parsed
return nil
}
func (t Role) IsAdmin() bool {
return t == Admin
}
func (t Role) IsManager() bool {
return t == Manager
}
func (t Role) IsDoctor() bool {
return t == Doctor
}
func (t Role) IsUser() bool {
return t == User
}
func (t Role) IsPrivileged() bool {
switch t {
case Doctor, Manager, Admin:
return true
default:
return false
}
}
@@ -0,0 +1,29 @@
package validator
import (
"context"
"github.com/go-playground/validator/v10"
)
type TagKey string
type ValidatorImpl struct {
validator *validator.Validate
}
func NewValidatorImpl() *ValidatorImpl {
return &ValidatorImpl{validator: validator.New()}
}
func (v *ValidatorImpl) Register(tag TagKey, fn validator.Func, callValidationEvenIfNull ...bool) error {
return v.validator.RegisterValidation(string(tag), fn, callValidationEvenIfNull...)
}
func (v *ValidatorImpl) ValidateCtx(ctx context.Context, value any) error {
return v.validator.StructCtx(ctx, value)
}
func (v *ValidatorImpl) Validate(value any) error {
return v.validator.Struct(value)
}
@@ -0,0 +1,205 @@
package attachment
import (
"context"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"os"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/pkg/objectstore"
)
type ScanResult struct {
Apply bool `json:"apply"`
Objects int `json:"objects"`
Metadata int `json:"metadata"`
Orphans int `json:"orphans"`
Fresh int `json:"fresh_orphans"`
Deleted int `json:"deleted"`
Missing int `json:"missing"`
Marked int `json:"marked_missing"`
Protected int `json:"referenced_objects"`
S3Requests int `json:"s3_requests"`
DBChecks int `json:"db_checks"`
LockAttempts int `json:"lock_attempts"`
DurationMS int64 `json:"duration_ms"`
GraceSeconds float64 `json:"grace_seconds"`
}
func (s *Service) Reconcile(ctx context.Context, apply bool) (result ScanResult, err error) {
start := time.Now()
result.Apply = apply
result.GraceSeconds = s.Config.Grace.Seconds()
defer func() { result.DurationMS = time.Since(start).Milliseconds() }()
if err = s.Repo.Pool.Ping(ctx); err != nil {
return
}
result.S3Requests++
if err = s.Store.Ping(ctx); err != nil {
return
}
pager := s3.NewListObjectsV2Paginator(s.Store.Client, &s3.ListObjectsV2Input{Bucket: &s.Store.Bucket, Prefix: aws.String(Prefix), MaxKeys: aws.Int32(100)})
for pager.HasMorePages() {
result.S3Requests++
page, e := pager.NextPage(ctx)
if e != nil {
return result, e
}
for _, obj := range page.Contents {
result.Objects++
key := aws.ToString(obj.Key)
if !ManagedKey(key) {
continue
}
result.LockAttempts++
conn, unlock, e := s.Repo.Lock(ctx, key)
if e != nil {
return result, e
}
e = func() error {
defer unlock()
result.DBChecks++
found, e := s.Repo.Exists(ctx, conn, key)
if e != nil {
return e
}
if found {
result.Protected++
return nil
}
// Re-read both metadata and object state under the same lock as upload.
result.S3Requests++
head, e := s.Store.Head(ctx, key)
if objectstore.Missing(e) {
return nil
}
if e != nil {
return e
}
result.Orphans++
if head.LastModified == nil || time.Since(*head.LastModified) <= s.Config.Grace {
result.Fresh++
return nil
}
if !apply {
return nil
}
result.DBChecks++
if _, e = conn.Exec(ctx, "SELECT 1"); e != nil {
return e
}
result.S3Requests++
if e = s.Store.Delete(ctx, key); e != nil {
return e
}
result.Deleted++
return nil
}()
if e != nil {
return result, e
}
}
}
after := uuid.Nil
for {
result.DBChecks++
page, e := s.Repo.Page(ctx, after)
if e != nil {
return result, e
}
if len(page) == 0 {
break
}
for _, a := range page {
result.Metadata++
after = a.Public.Id
result.LockAttempts++
conn, unlock, e := s.Repo.Lock(ctx, a.Key)
if e != nil {
return result, e
}
e = func() error {
defer unlock()
result.S3Requests++
_, e := s.Store.Head(ctx, a.Key)
if e == nil {
return nil
}
if !objectstore.Missing(e) {
return e
}
result.Missing++
if apply {
result.DBChecks++
changed, err := s.Repo.MarkMissing(ctx, conn, a.Public.Id, true)
if err != nil {
return err
}
if changed {
result.Marked++
}
}
return nil
}()
if e != nil {
return result, e
}
}
}
return result, nil
}
func (s *Service) Restore(ctx context.Context, id uuid.UUID, path string) error {
a, e := s.Repo.Get(ctx, id)
if e != nil {
return e
}
f, e := os.Open(path)
if e != nil {
return e
}
defer f.Close()
hash := sha256.New()
size, e := io.Copy(hash, io.LimitReader(f, s.Config.MaxBytes+1))
if e != nil {
return e
}
if size != int64(a.Public.SizeBytes) || hex.EncodeToString(hash.Sum(nil)) != a.Public.Sha256 {
return fmt.Errorf("original checksum or size mismatch")
}
if e = s.Validate(ctx, f, string(a.Public.ContentType)); e != nil {
return e
}
conn, unlock, e := s.Repo.Lock(ctx, a.Key)
if e != nil {
return e
}
defer unlock()
if _, e = f.Seek(0, 0); e != nil {
return e
}
if e = s.Store.Put(ctx, a.Key, string(a.Public.ContentType), f, size); e != nil {
return e
}
obj, e := s.Store.Get(ctx, a.Key)
if e != nil {
return e
}
defer obj.Body.Close()
hash.Reset()
n, e := io.Copy(hash, io.LimitReader(obj.Body, s.Config.MaxBytes+1))
if e != nil {
return e
}
if n != size || hex.EncodeToString(hash.Sum(nil)) != a.Public.Sha256 {
return fmt.Errorf("stored original verification failed")
}
_, e = s.Repo.MarkMissing(ctx, conn, id, false)
return e
}

Some files were not shown because too many files have changed in this diff Show More