Единый бинарник с objectstore/reconcile, pinned MinIO при недоступности Docker Hub, автотесты и evidence на оценку 5.
768 lines
26 KiB
Go
768 lines
26 KiB
Go
// Package api — HTTP-слой lab4 (lab3 + вложения в S3).
|
||
//
|
||
// Порядок обработки запроса:
|
||
// 1. X-Request-Id и X-Instance-Id на каждый ответ, включая ошибки;
|
||
// 2. журнал method/path/status без текста сообщений и без токена;
|
||
// 3. маршрут;
|
||
// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают.
|
||
//
|
||
// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL, Redis
|
||
// и S3: без них нельзя честно принять запись, узнать, кто делает запрос, или принять/отдать
|
||
// вложение (lab4: недоступный S3 → 503, балансировщик снимает реплику).
|
||
//
|
||
// POST сообщения требует Idempotency-Key; результат хранится в общей БД, а не в памяти реплики.
|
||
package api
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"crypto/sha256"
|
||
"encoding/base64"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log"
|
||
"net/http"
|
||
"os"
|
||
"strconv"
|
||
"strings"
|
||
"sync/atomic"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"github.com/google/uuid"
|
||
|
||
"mtusi2026lab4/internal/objectstore"
|
||
"mtusi2026lab4/internal/session"
|
||
"mtusi2026lab4/internal/store"
|
||
)
|
||
|
||
type ctxKey int
|
||
|
||
const (
|
||
userKey ctxKey = iota
|
||
tokenKey
|
||
requestIDKey
|
||
)
|
||
|
||
const (
|
||
challengeBasic = `Basic realm="messenger", charset="UTF-8"`
|
||
challengeBearer = `Bearer realm="messenger"`
|
||
)
|
||
|
||
// Server связывает HTTP с PostgreSQL и Redis.
|
||
type Server struct {
|
||
Store *store.Store
|
||
Sessions *session.Store
|
||
Objects *objectstore.Store // приватный S3-bucket с оригиналами вложений
|
||
InstanceID string
|
||
ready atomic.Bool
|
||
|
||
// uploadSlots — семафор одновременных загрузок (ограничивает пик RAM, см. attachments.go).
|
||
uploadSlots chan struct{}
|
||
|
||
// AfterObjectPut — тестовый hook: вызывается после успешного PUT в S3 и до INSERT в PG.
|
||
// Позволяет в тестах смоделировать отказ «между S3 и БД». В проде всегда nil.
|
||
AfterObjectPut func(key string)
|
||
}
|
||
|
||
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
|
||
// instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса.
|
||
func New(st *store.Store, sessions *session.Store, objects *objectstore.Store, instanceID string) *Server {
|
||
s := &Server{Store: st, Sessions: sessions, Objects: objects, InstanceID: instanceID}
|
||
s.uploadSlots = make(chan struct{}, 4) // значение по умолчанию; main задаёт UPLOAD_MAX_CONCURRENCY
|
||
s.ready.Store(true)
|
||
return s
|
||
}
|
||
|
||
// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready.
|
||
// HAProxy/Traefik с httpchk на /health/ready перестаёт слать трафик на эту реплику.
|
||
func (s *Server) BeginDrain() { s.ready.Store(false) }
|
||
|
||
// Handler собирает маршруты lab4.
|
||
func (s *Server) Handler() http.Handler {
|
||
mux := http.NewServeMux()
|
||
mux.HandleFunc("GET /health/live", s.handleLive)
|
||
mux.HandleFunc("GET /health/ready", s.handleReady)
|
||
mux.HandleFunc("POST /api/v1/users", s.handleCreateUser)
|
||
mux.HandleFunc("POST /api/v1/auth/sessions", s.handleCreateSession)
|
||
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", s.requireUser(s.handleRevokeSession))
|
||
mux.HandleFunc("GET /api/v1/users/me", s.requireUser(s.handleMe))
|
||
mux.HandleFunc("POST /api/v1/chats", s.requireUser(s.handleCreateChat))
|
||
mux.HandleFunc("GET /api/v1/chats", s.requireUser(s.handleListChats))
|
||
mux.HandleFunc("GET /api/v1/chats/{chat_id}", s.requireUser(s.handleGetChat))
|
||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleCreateMessage))
|
||
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleListMessages))
|
||
// lab4: вложения. Загрузка — сырой binary (не multipart), метаданные и байты — через API.
|
||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", s.requireUser(s.handleUploadAttachment))
|
||
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", s.requireUser(s.handleGetAttachment))
|
||
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", s.requireUser(s.handleDownloadAttachment))
|
||
return s.withInstanceID(s.withRequestID(s.withAccessLog(mux)))
|
||
}
|
||
|
||
func (s *Server) handleLive(w http.ResponseWriter, r *http.Request) {
|
||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||
}
|
||
|
||
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
|
||
if !s.ready.Load() {
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "service is shutting down")
|
||
return
|
||
}
|
||
// lab4: S3 — критичная зависимость обязательного синхронного пути (загрузка/скачивание).
|
||
// Недоступное хранилище → 503, чтобы LB не слал трафик на реплику, которая не может
|
||
// выполнить контракт; сообщения без вложений при этом тоже временно недоступны
|
||
// (осознанное упрощение: readiness один на реплику, см. REPORT).
|
||
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil || s.Objects.Ping(r.Context()) != nil {
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||
}
|
||
|
||
func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) {
|
||
var body struct {
|
||
Username string `json:"username"`
|
||
DisplayName string `json:"display_name"`
|
||
Password string `json:"password"`
|
||
}
|
||
if err := decodeStrict(r, &body); err != nil {
|
||
writeDecodeErr(w, r, err)
|
||
return
|
||
}
|
||
if !validUsername(body.Username) {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
|
||
return
|
||
}
|
||
display := strings.TrimSpace(body.DisplayName)
|
||
if display == "" || utf8.RuneCountInString(display) > 100 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
|
||
return
|
||
}
|
||
if n := utf8.RuneCountInString(body.Password); n < 12 || n > 128 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
|
||
return
|
||
}
|
||
u, err := s.Store.CreateUser(r.Context(), body.Username, display, body.Password)
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, http.StatusConflict, "conflict", "username already taken")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusCreated, userDTO(u))
|
||
}
|
||
|
||
func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) {
|
||
// Контракт: только Basic, без JSON body. Любые байты в теле — 400, не тихий игнор.
|
||
rawBody, err := io.ReadAll(io.LimitReader(r.Body, 4096))
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid body")
|
||
return
|
||
}
|
||
if len(bytes.TrimSpace(rawBody)) != 0 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "session create must not have a body")
|
||
return
|
||
}
|
||
username, password, ok := parseBasic(r.Header.Get("Authorization"))
|
||
if !ok || !validUsername(username) {
|
||
writeAuthError(w, r, challengeBasic)
|
||
return
|
||
}
|
||
if n := utf8.RuneCountInString(password); n < 12 || n > 128 {
|
||
writeAuthError(w, r, challengeBasic)
|
||
return
|
||
}
|
||
u, err := s.Store.Authenticate(r.Context(), username, password)
|
||
if errors.Is(err, store.ErrNotFound) {
|
||
writeAuthError(w, r, challengeBasic)
|
||
return
|
||
}
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, 0, "", "")
|
||
return
|
||
}
|
||
token, exp, err := s.Sessions.Issue(r.Context(), u.ID)
|
||
if err != nil {
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusCreated, map[string]any{
|
||
"token": token,
|
||
"token_type": "Bearer",
|
||
"expires_at": formatTime(exp),
|
||
"user": userDTO(u),
|
||
})
|
||
}
|
||
|
||
func (s *Server) handleRevokeSession(w http.ResponseWriter, r *http.Request) {
|
||
token, _ := r.Context().Value(tokenKey).(string)
|
||
if err := s.Sessions.Revoke(r.Context(), token); err != nil {
|
||
if errors.Is(err, session.ErrUnauthorized) {
|
||
writeAuthError(w, r, challengeBearer)
|
||
return
|
||
}
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||
return
|
||
}
|
||
w.WriteHeader(http.StatusNoContent)
|
||
}
|
||
|
||
func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
|
||
u, err := s.Store.GetUser(r.Context(), userFrom(r))
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, userDTO(u))
|
||
}
|
||
|
||
func (s *Server) handleCreateChat(w http.ResponseWriter, r *http.Request) {
|
||
var body struct {
|
||
Title string `json:"title"`
|
||
MemberIDs []string `json:"member_ids"`
|
||
}
|
||
if err := decodeStrict(r, &body); err != nil {
|
||
writeDecodeErr(w, r, err)
|
||
return
|
||
}
|
||
title := strings.TrimSpace(body.Title)
|
||
if title == "" || utf8.RuneCountInString(title) > 100 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
|
||
return
|
||
}
|
||
if len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
|
||
return
|
||
}
|
||
uid := userFrom(r)
|
||
seen := make(map[uuid.UUID]struct{}, len(body.MemberIDs))
|
||
ids := make([]uuid.UUID, 0, len(body.MemberIDs))
|
||
callerPresent := false
|
||
for _, raw := range body.MemberIDs {
|
||
id, err := uuid.Parse(raw)
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member id")
|
||
return
|
||
}
|
||
if _, dup := seen[id]; dup {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate member id")
|
||
return
|
||
}
|
||
seen[id] = struct{}{}
|
||
if id == uid {
|
||
callerPresent = true
|
||
}
|
||
ids = append(ids, id)
|
||
}
|
||
if !callerPresent {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "caller must be a member")
|
||
return
|
||
}
|
||
chat, err := s.Store.CreateChat(r.Context(), title, ids)
|
||
if errors.Is(err, store.ErrNotFound) {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "unknown member")
|
||
return
|
||
}
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, 0, "", "")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusCreated, chatDTO(chat))
|
||
}
|
||
|
||
func (s *Server) handleListChats(w http.ResponseWriter, r *http.Request) {
|
||
uid := userFrom(r)
|
||
limit, after, err := parsePage(r, "chats:"+uid.String())
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||
return
|
||
}
|
||
items, next, err := s.Store.ListChats(r.Context(), uid, limit, after)
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||
return
|
||
}
|
||
out := make([]any, len(items))
|
||
for i := range items {
|
||
out[i] = chatDTO(&items[i])
|
||
}
|
||
var cursor *store.PageCursor
|
||
if next != nil {
|
||
cursor = &store.PageCursor{Scope: "chats:" + uid.String(), CreatedAt: next.CreatedAt, ID: next.ID}
|
||
}
|
||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||
}
|
||
|
||
func (s *Server) handleGetChat(w http.ResponseWriter, r *http.Request) {
|
||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||
return
|
||
}
|
||
chat, err := s.Store.GetChat(r.Context(), chatID, userFrom(r))
|
||
if errors.Is(err, store.ErrNotFound) {
|
||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||
return
|
||
}
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, 0, "", "")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, chatDTO(chat))
|
||
}
|
||
|
||
func (s *Server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
|
||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||
return
|
||
}
|
||
idemKey := r.Header.Get("Idempotency-Key")
|
||
if !validIdempotencyKey(idemKey) {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing Idempotency-Key")
|
||
return
|
||
}
|
||
var body struct {
|
||
Text string `json:"text"`
|
||
AttachmentIDs []string `json:"attachment_ids"`
|
||
}
|
||
if err := decodeStrict(r, &body); err != nil {
|
||
writeDecodeErr(w, r, err)
|
||
return
|
||
}
|
||
// attachment_ids: 0–10 уникальных UUID, по умолчанию []. Отсутствующий ключ, null и []
|
||
// равны. UUID нормализуем (нижний регистр, канонический вид): иначе «ABC…» и «abc…»
|
||
// давали бы разные хэши идемпотентности и дубль в uniqueItems.
|
||
if len(body.AttachmentIDs) > 10 {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "too many attachment_ids")
|
||
return
|
||
}
|
||
attachmentIDs := make([]uuid.UUID, 0, len(body.AttachmentIDs))
|
||
canonicalIDs := make([]string, 0, len(body.AttachmentIDs))
|
||
seenAtt := make(map[uuid.UUID]struct{}, len(body.AttachmentIDs))
|
||
for _, raw := range body.AttachmentIDs {
|
||
id, err := uuid.Parse(raw)
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id")
|
||
return
|
||
}
|
||
if _, dup := seenAtt[id]; dup {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate attachment id")
|
||
return
|
||
}
|
||
seenAtt[id] = struct{}{}
|
||
attachmentIDs = append(attachmentIDs, id)
|
||
canonicalIDs = append(canonicalIDs, id.String())
|
||
}
|
||
// Непустота — по TrimSpace; длина и сохранение — по исходному тексту.
|
||
// Иначе пробелы по краям пропадают, а строка «пробел + 4000 букв» проходит как 4000.
|
||
// lab4: пустой текст допустим, если есть хотя бы одно вложение (сообщение «только файл»).
|
||
if utf8.RuneCountInString(body.Text) > 4000 ||
|
||
(strings.TrimSpace(body.Text) == "" && len(attachmentIDs) == 0) {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text")
|
||
return
|
||
}
|
||
path := "/api/v1/chats/" + chatID.String() + "/messages"
|
||
reqHash := idempotencyRequestHash(body.Text, canonicalIDs)
|
||
result, err := s.Store.CreateMessageIdempotent(
|
||
r.Context(), chatID, userFrom(r), body.Text, attachmentIDs,
|
||
http.MethodPost, path, idemKey, reqHash,
|
||
)
|
||
if errors.Is(err, store.ErrNotFound) {
|
||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||
return
|
||
}
|
||
if errors.Is(err, store.ErrIdempotencyConflict) {
|
||
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
|
||
return
|
||
}
|
||
if errors.Is(err, store.ErrAttachmentNotReady) {
|
||
writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready")
|
||
return
|
||
}
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, 0, "", "")
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusCreated, messageDTO(result.Message))
|
||
}
|
||
|
||
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||
return
|
||
}
|
||
scope := "chat:" + chatID.String()
|
||
limit, after, err := parsePage(r, scope)
|
||
if err != nil {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||
return
|
||
}
|
||
items, next, err := s.Store.ListMessages(r.Context(), chatID, userFrom(r), limit, after)
|
||
if errors.Is(err, store.ErrNotFound) {
|
||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||
return
|
||
}
|
||
if err != nil {
|
||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||
return
|
||
}
|
||
out := make([]any, len(items))
|
||
for i := range items {
|
||
out[i] = messageDTO(&items[i])
|
||
}
|
||
var cursor *store.PageCursor
|
||
if next != nil {
|
||
cursor = &store.PageCursor{Scope: scope, CreatedAt: next.CreatedAt, ID: next.ID}
|
||
}
|
||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||
}
|
||
|
||
// requireUser принимает только Authorization: Bearer. X-User-Id не читается.
|
||
// Basic на бизнес-методе — тот же 401, но с Bearer-challenge, не с Basic.
|
||
func (s *Server) requireUser(next http.HandlerFunc) http.HandlerFunc {
|
||
return func(w http.ResponseWriter, r *http.Request) {
|
||
header := r.Header.Get("Authorization")
|
||
if strings.HasPrefix(strings.ToLower(header), "basic ") {
|
||
writeAuthError(w, r, challengeBearer)
|
||
return
|
||
}
|
||
token, ok := parseBearer(header)
|
||
if !ok {
|
||
writeAuthError(w, r, challengeBearer)
|
||
return
|
||
}
|
||
uid, err := s.Sessions.Lookup(r.Context(), token)
|
||
if errors.Is(err, session.ErrUnauthorized) {
|
||
writeAuthError(w, r, challengeBearer)
|
||
return
|
||
}
|
||
if err != nil {
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||
return
|
||
}
|
||
ctx := context.WithValue(r.Context(), userKey, uid)
|
||
ctx = context.WithValue(ctx, tokenKey, token)
|
||
next(w, r.WithContext(ctx))
|
||
}
|
||
}
|
||
|
||
func userFrom(r *http.Request) uuid.UUID {
|
||
id, _ := r.Context().Value(userKey).(uuid.UUID)
|
||
return id
|
||
}
|
||
|
||
func (s *Server) withRequestID(next http.Handler) http.Handler {
|
||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
rid := r.Header.Get("X-Request-Id")
|
||
if rid == "" {
|
||
rid = uuid.NewString()
|
||
}
|
||
w.Header().Set("X-Request-Id", rid)
|
||
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, rid)))
|
||
})
|
||
}
|
||
|
||
func (s *Server) withInstanceID(next http.Handler) http.Handler {
|
||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
w.Header().Set("X-Instance-Id", s.InstanceID)
|
||
next.ServeHTTP(w, r)
|
||
})
|
||
}
|
||
|
||
// validIdempotencyKey — ASCII [A-Za-z0-9._:-]{1,128}.
|
||
func validIdempotencyKey(key string) bool {
|
||
if len(key) < 1 || len(key) > 128 {
|
||
return false
|
||
}
|
||
for i := 0; i < len(key); i++ {
|
||
c := key[i]
|
||
switch {
|
||
case c >= 'A' && c <= 'Z', c >= 'a' && c <= 'z', c >= '0' && c <= '9':
|
||
case c == '.', c == '_', c == ':', c == '-':
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// idempotencyRequestHash канонизирует тело: порядок ключей JSON не важен,
|
||
// отсутствующий attachment_ids равен []. Хэш — SHA-256 hex.
|
||
func idempotencyRequestHash(text string, attachmentIDs []string) string {
|
||
if attachmentIDs == nil {
|
||
attachmentIDs = []string{}
|
||
}
|
||
payload, _ := json.Marshal(struct {
|
||
Text string `json:"text"`
|
||
AttachmentIDs []string `json:"attachment_ids"`
|
||
}{Text: text, AttachmentIDs: attachmentIDs})
|
||
sum := sha256.Sum256(payload)
|
||
return hex.EncodeToString(sum[:])
|
||
}
|
||
|
||
type statusRecorder struct {
|
||
http.ResponseWriter
|
||
status int
|
||
}
|
||
|
||
func (s *statusRecorder) WriteHeader(code int) {
|
||
s.status = code
|
||
s.ResponseWriter.WriteHeader(code)
|
||
}
|
||
|
||
func (s *Server) withAccessLog(next http.Handler) http.Handler {
|
||
quiet := strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "0") || strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "false")
|
||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
start := time.Now()
|
||
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
|
||
next.ServeHTTP(rec, r)
|
||
if quiet && rec.status < 400 {
|
||
return
|
||
}
|
||
if strings.HasPrefix(r.URL.Path, "/health/") && rec.status == http.StatusOK {
|
||
return
|
||
}
|
||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||
// path без query: в cursor нет секрета, но и текста сообщения в логе быть не должно.
|
||
log.Printf("method=%s path=%s status=%d request_id=%s duration_ms=%d",
|
||
r.Method, r.URL.Path, rec.status, rid, time.Since(start).Milliseconds())
|
||
})
|
||
}
|
||
|
||
func parsePage(r *http.Request, expectedScope string) (int, *store.PageCursor, error) {
|
||
limit := 50
|
||
if raw := r.URL.Query().Get("limit"); raw != "" {
|
||
n, err := strconv.Atoi(raw)
|
||
if err != nil || n < 1 || n > 100 {
|
||
return 0, nil, fmt.Errorf("invalid limit")
|
||
}
|
||
limit = n
|
||
}
|
||
rawCursor := r.URL.Query().Get("cursor")
|
||
if rawCursor == "" {
|
||
return limit, nil, nil
|
||
}
|
||
cur, err := decodeCursor(rawCursor)
|
||
if err != nil || cur.Scope != expectedScope {
|
||
return 0, nil, fmt.Errorf("invalid cursor")
|
||
}
|
||
return limit, cur, nil
|
||
}
|
||
|
||
func encodeCursor(c *store.PageCursor) string {
|
||
payload := fmt.Sprintf("%s|%s|%s", c.Scope, c.CreatedAt.UTC().Format(time.RFC3339Nano), c.ID.String())
|
||
return base64.RawURLEncoding.EncodeToString([]byte(payload))
|
||
}
|
||
|
||
func decodeCursor(raw string) (*store.PageCursor, error) {
|
||
b, err := base64.RawURLEncoding.DecodeString(raw)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
parts := strings.SplitN(string(b), "|", 3)
|
||
if len(parts) != 3 {
|
||
return nil, fmt.Errorf("bad cursor")
|
||
}
|
||
ts, err := time.Parse(time.RFC3339Nano, parts[1])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
id, err := uuid.Parse(parts[2])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &store.PageCursor{Scope: parts[0], CreatedAt: ts.UTC(), ID: id}, nil
|
||
}
|
||
|
||
func validUsername(s string) bool {
|
||
if len(s) < 3 || len(s) > 32 {
|
||
return false
|
||
}
|
||
for _, c := range s {
|
||
if (c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func decodeStrict(r *http.Request, dst any) error {
|
||
ct := r.Header.Get("Content-Type")
|
||
if ct != "" && !strings.HasPrefix(strings.ToLower(strings.TrimSpace(ct)), "application/json") {
|
||
return errUnsupported
|
||
}
|
||
// Читаем тело целиком: Decoder.More() не ловит хвост вида {"text":"x"}} —
|
||
// после одного объекта More()=false, а лишняя скобка всё равно остаётся.
|
||
raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
|
||
if err != nil {
|
||
return errMalformed
|
||
}
|
||
dec := json.NewDecoder(bytes.NewReader(raw))
|
||
dec.DisallowUnknownFields()
|
||
if err := dec.Decode(dst); err != nil {
|
||
return errMalformed
|
||
}
|
||
rest := bytes.TrimSpace(raw[dec.InputOffset():])
|
||
if len(rest) != 0 {
|
||
return errMalformed
|
||
}
|
||
return nil
|
||
}
|
||
|
||
var (
|
||
errUnsupported = errors.New("unsupported media type")
|
||
errMalformed = errors.New("malformed json")
|
||
)
|
||
|
||
func writeDecodeErr(w http.ResponseWriter, r *http.Request, err error) {
|
||
if errors.Is(err, errUnsupported) {
|
||
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "unsupported media type")
|
||
return
|
||
}
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed json")
|
||
}
|
||
|
||
func parseBasic(header string) (string, string, bool) {
|
||
const prefix = "basic "
|
||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||
return "", "", false
|
||
}
|
||
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
|
||
if err != nil || !utf8.Valid(raw) {
|
||
return "", "", false
|
||
}
|
||
user, pass, ok := strings.Cut(string(raw), ":")
|
||
if !ok || user == "" {
|
||
return "", "", false
|
||
}
|
||
return user, pass, true
|
||
}
|
||
|
||
func parseBearer(header string) (string, bool) {
|
||
const prefix = "bearer "
|
||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||
return "", false
|
||
}
|
||
token := strings.TrimSpace(header[len(prefix):])
|
||
if token == "" || strings.Contains(token, " ") {
|
||
return "", false
|
||
}
|
||
return token, true
|
||
}
|
||
|
||
func userDTO(u *store.User) map[string]any {
|
||
return map[string]any{
|
||
"id": u.ID.String(),
|
||
"username": u.Username,
|
||
"display_name": u.DisplayName,
|
||
"created_at": formatTime(u.CreatedAt),
|
||
}
|
||
}
|
||
|
||
func chatDTO(c *store.Chat) map[string]any {
|
||
ids := make([]string, len(c.MemberIDs))
|
||
for i, id := range c.MemberIDs {
|
||
ids[i] = id.String()
|
||
}
|
||
return map[string]any{
|
||
"id": c.ID.String(),
|
||
"title": c.Title,
|
||
"member_ids": ids,
|
||
"created_at": formatTime(c.CreatedAt),
|
||
}
|
||
}
|
||
|
||
func messageDTO(m *store.Message) map[string]any {
|
||
// attachment_ids обязателен в ответе (контракт 1.4.0): всегда массив, не null.
|
||
ids := make([]string, len(m.AttachmentIDs))
|
||
for i, id := range m.AttachmentIDs {
|
||
ids[i] = id.String()
|
||
}
|
||
return map[string]any{
|
||
"id": m.ID.String(),
|
||
"chat_id": m.ChatID.String(),
|
||
"sender_id": m.SenderID.String(),
|
||
"text": m.Text,
|
||
"created_at": formatTime(m.CreatedAt),
|
||
"attachment_ids": ids,
|
||
}
|
||
}
|
||
|
||
func pageDTO(items []any, next *store.PageCursor) map[string]any {
|
||
var cursor any
|
||
if next != nil {
|
||
cursor = encodeCursor(next)
|
||
}
|
||
if items == nil {
|
||
items = []any{}
|
||
}
|
||
return map[string]any{"items": items, "next_cursor": cursor}
|
||
}
|
||
|
||
func formatTime(t time.Time) string {
|
||
return t.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z")
|
||
}
|
||
|
||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.WriteHeader(status)
|
||
enc := json.NewEncoder(w)
|
||
enc.SetEscapeHTML(false)
|
||
_ = enc.Encode(v)
|
||
}
|
||
|
||
func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
|
||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||
if rid == "" {
|
||
rid = w.Header().Get("X-Request-Id")
|
||
}
|
||
writeJSON(w, status, map[string]any{
|
||
"error": map[string]any{
|
||
"code": code,
|
||
"message": message,
|
||
"request_id": rid,
|
||
},
|
||
})
|
||
}
|
||
|
||
func writeAuthError(w http.ResponseWriter, r *http.Request, challenge string) {
|
||
w.Header().Set("WWW-Authenticate", challenge)
|
||
writeError(w, r, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||
}
|
||
|
||
// writeStoreErr прячет текст драйвера. fallbackStatus используется для ожидаемой доменной ошибки.
|
||
func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error, fallbackStatus int, fallbackCode, fallbackMessage string) {
|
||
switch {
|
||
case errors.Is(err, store.ErrUnavailable):
|
||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||
case errors.Is(err, store.ErrIdempotencyConflict):
|
||
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
|
||
case errors.Is(err, store.ErrConflict) && fallbackStatus != 0:
|
||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||
case errors.Is(err, store.ErrNotFound) && fallbackStatus != 0:
|
||
if fallbackCode == "unauthorized" {
|
||
writeAuthError(w, r, challengeBearer)
|
||
return
|
||
}
|
||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||
case errors.Is(err, store.ErrInvalidCursor):
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||
default:
|
||
if errors.Is(err, store.ErrConflict) {
|
||
writeError(w, r, http.StatusConflict, "conflict", "username already taken")
|
||
return
|
||
}
|
||
// В лог — только тип, без SQL и без текста, который драйвер мог вложить в ошибку.
|
||
log.Printf("request_id=%s store_error_type=%T", requestID(r), err)
|
||
writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error")
|
||
}
|
||
}
|
||
|
||
func requestID(r *http.Request) string {
|
||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||
return rid
|
||
}
|