// Package api — HTTP-слой lab3. // // Порядок обработки запроса: // 1. X-Request-Id и X-Instance-Id на каждый ответ, включая ошибки; // 2. журнал method/path/status без текста сообщений и без токена; // 3. маршрут; // 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают. // // /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL и Redis: // без них нельзя честно принять запись или узнать, кто делает запрос. // // 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" "mtusi2026lab3/internal/session" "mtusi2026lab3/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 InstanceID string ready atomic.Bool } // New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready. // instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса. func New(st *store.Store, sessions *session.Store, instanceID string) *Server { s := &Server{Store: st, Sessions: sessions, InstanceID: instanceID} 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 собирает маршруты 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.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 } 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) { // Контракт: только 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 } // Непустота — по TrimSpace; длина и сохранение — по исходному тексту. // Иначе пробелы по краям пропадают, а строка «пробел + 4000 букв» проходит как 4000. if strings.TrimSpace(body.Text) == "" || utf8.RuneCountInString(body.Text) > 4000 { writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text") return } // attachment_ids в lab3 ещё не поддерживаются; непустой список — 400. // Отсутствующий ключ и [] семантически равны для хэша идемпотентности. if body.AttachmentIDs == nil { body.AttachmentIDs = []string{} } if len(body.AttachmentIDs) != 0 { writeError(w, r, http.StatusBadRequest, "invalid_request", "attachments are not supported in lab3") return } path := "/api/v1/chats/" + chatID.String() + "/messages" reqHash := idempotencyRequestHash(body.Text, body.AttachmentIDs) result, err := s.Store.CreateMessageIdempotent( r.Context(), chatID, userFrom(r), body.Text, 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 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 { 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.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 }