Метаданные в PostgreSQL, байты в приватном bucket; sync upload 201 ready; компенсация orphan и cmd/reconcile с dry-run/apply и grace period.
781 lines
26 KiB
Go
781 lines
26 KiB
Go
// Package api — HTTP-слой lab4 (поверх lab3: LB, идемпотентность, сессии в Redis).
|
||
//
|
||
// Порядок обработки запроса:
|
||
// 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:
|
||
// без них нельзя честно принять запись или узнать, кто делает запрос.
|
||
//
|
||
// POST сообщения требует Idempotency-Key; результат хранится в общей БД, а не в памяти реплики.
|
||
//
|
||
// Вложения (attachments.go): сырой PNG/JPEG в теле POST, байты в приватном S3, метаданные в
|
||
// PostgreSQL. Скачивание — только через этот API, без редиректа на S3.
|
||
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/blob"
|
||
"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"`
|
||
)
|
||
|
||
// Лимиты вложений по контракту lab4.
|
||
const (
|
||
DefaultMaxUploadBytes int64 = 10 << 20 // 10 MiB = 10 485 760
|
||
DefaultMaxImagePixels int64 = 40_000_000
|
||
)
|
||
|
||
// BlobStore — то, что API требует от S3-клиента. *blob.Client его реализует;
|
||
// интерфейс нужен, чтобы тест мог подставить недоступное хранилище.
|
||
type BlobStore interface {
|
||
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
|
||
Get(ctx context.Context, key string) (io.ReadCloser, error)
|
||
Delete(ctx context.Context, key string) error
|
||
Ping(ctx context.Context) error
|
||
}
|
||
|
||
var _ BlobStore = (*blob.Client)(nil)
|
||
|
||
// Server связывает HTTP с PostgreSQL, Redis и S3.
|
||
type Server struct {
|
||
Store *store.Store
|
||
Sessions *session.Store
|
||
Blob BlobStore
|
||
InstanceID string
|
||
// Лимиты загрузки. По умолчанию контрактные; main.go может только ужесточить.
|
||
MaxUploadBytes int64
|
||
MaxImagePixels int64
|
||
ready atomic.Bool
|
||
}
|
||
|
||
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
|
||
// instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса.
|
||
func New(st *store.Store, sessions *session.Store, bl BlobStore, instanceID string) *Server {
|
||
s := &Server{
|
||
Store: st, Sessions: sessions, Blob: bl, InstanceID: instanceID,
|
||
MaxUploadBytes: DefaultMaxUploadBytes,
|
||
MaxImagePixels: DefaultMaxImagePixels,
|
||
}
|
||
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))
|
||
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
|
||
}
|
||
// S3 — обязательная зависимость синхронного пути (загрузка и скачивание вложений).
|
||
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil ||
|
||
s.Blob.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 и [] равны для хэша.
|
||
if len(body.AttachmentIDs) > maxMessageAttachments {
|
||
writeError(w, r, http.StatusBadRequest, "invalid_request", "too many attachments")
|
||
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, но только если вложений нет:
|
||
// text="" с хотя бы одним вложением разрешён контрактом lab4.
|
||
// Пробелы по краям сохраняются как есть, иначе «пробел + 4000 букв» проходил бы как 4000.
|
||
if utf8.RuneCountInString(body.Text) > 4000 ||
|
||
(len(attachmentIDs) == 0 && strings.TrimSpace(body.Text) == "") {
|
||
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.ErrNotReady) {
|
||
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 {
|
||
// Всегда массив, даже пустой: клиент lab3 без вложений видит [] (контракт 1.4.0).
|
||
att := make([]string, len(m.AttachmentIDs))
|
||
for i, id := range m.AttachmentIDs {
|
||
att[i] = id.String()
|
||
}
|
||
return map[string]any{
|
||
"id": m.ID.String(),
|
||
"chat_id": m.ChatID.String(),
|
||
"sender_id": m.SenderID.String(),
|
||
"text": m.Text,
|
||
"attachment_ids": att,
|
||
"created_at": formatTime(m.CreatedAt),
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|