Files
mtusi2026lab2/internal/api/server.go
T
Mlvn 096c53ecdb Перенести мессенджер на PostgreSQL и сессии Redis.
Сообщения должны переживать рестарт, а доступ идти через Bearer, а не X-User-Id. Трек 2 сравнивает план keyset-запроса и сверяет pg_restore.
2026-10-14 22:47:08 +03:00

631 lines
19 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Package api — HTTP-слой lab2.
//
// Порядок обработки запроса:
// 1. X-Request-Id на каждый ответ, включая ошибки;
// 2. журнал method/path/status без текста сообщений и без токена;
// 3. маршрут;
// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают.
//
// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL и Redis:
// без них нельзя честно принять запись или узнать, кто делает запрос.
package api
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"log"
"net/http"
"os"
"strconv"
"strings"
"sync/atomic"
"time"
"unicode/utf8"
"github.com/google/uuid"
"mtusi2026lab2/internal/session"
"mtusi2026lab2/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
ready atomic.Bool
}
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
func New(st *store.Store, sessions *session.Store) *Server {
s := &Server{Store: st, Sessions: sessions}
s.ready.Store(true)
return s
}
// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready.
func (s *Server) BeginDrain() { s.ready.Store(false) }
// Handler собирает маршруты lab2. Идемпотентности и вложений здесь нет — это lab3+.
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))
return 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
}
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.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) {
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
}
var body struct {
Text string `json:"text"`
}
if err := decodeStrict(r, &body); err != nil {
writeDecodeErr(w, r, err)
return
}
text := strings.TrimSpace(body.Text)
if text == "" || utf8.RuneCountInString(text) > 4000 {
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text")
return
}
msg, err := s.Store.CreateMessage(r.Context(), chatID, userFrom(r), text)
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.StatusCreated, messageDTO(msg))
}
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)))
})
}
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
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
return errMalformed
}
if dec.More() {
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 {
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),
}
}
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.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
}