forked from mtusi2026/mtusi2026lab2
156 lines
5.0 KiB
Go
156 lines
5.0 KiB
Go
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"runtime/debug"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"backend/internal/domain/model"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type ctxKey int
|
|
|
|
const (
|
|
requestIDKey ctxKey = iota
|
|
userKey
|
|
)
|
|
|
|
// requestID ставит X-Request-Id в каждый ответ, включая ошибки и health.
|
|
func requestID(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
id := uuid.NewString()
|
|
w.Header().Set("X-Request-Id", id)
|
|
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, id)))
|
|
})
|
|
}
|
|
|
|
func requestIDFrom(ctx context.Context) string {
|
|
id, _ := ctx.Value(requestIDKey).(string)
|
|
return id
|
|
}
|
|
|
|
// recoverer превращает панику в 500 без деталей; стек — только в лог.
|
|
func (h *API) recoverer(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
defer func() {
|
|
rec := recover()
|
|
if rec == nil {
|
|
return
|
|
}
|
|
if rec == http.ErrAbortHandler {
|
|
panic(rec)
|
|
}
|
|
h.log.Error().Interface("panic", rec).Bytes("stack", debug.Stack()).
|
|
Str("request_id", requestIDFrom(r.Context())).Msg("panic")
|
|
h.writeError(w, r, errors.New("panic"))
|
|
}()
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
// accessLog пишет метод, шаблон маршрута, статус и длительность. Тело, query
|
|
// и заголовки не логируются: там текст сообщений и идентификаторы.
|
|
func (h *API) accessLog(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
|
|
next.ServeHTTP(ww, r)
|
|
route := chi.RouteContext(r.Context()).RoutePattern()
|
|
if route == "" {
|
|
route = "unmatched"
|
|
}
|
|
event := h.log.Info()
|
|
if ww.Status() >= http.StatusInternalServerError {
|
|
event = h.log.Warn()
|
|
}
|
|
event.Str("request_id", requestIDFrom(r.Context())).
|
|
Str("method", r.Method).
|
|
Str("route", route).
|
|
Int("status", ww.Status()).
|
|
Dur("duration", time.Since(start)).
|
|
Msg("request")
|
|
})
|
|
}
|
|
|
|
// authenticate verifies persisted Bearer sessions for protected business routes.
|
|
// The session-creation endpoint separately validates Basic credentials.
|
|
func (h *API) authenticate(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
parts := strings.Fields(r.Header.Get("Authorization"))
|
|
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
|
|
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
|
|
h.writeError(w, r, model.ErrUnauthorized)
|
|
return
|
|
}
|
|
user, err := h.auth.Authenticate(r.Context(), parts[1])
|
|
if err != nil {
|
|
if errors.Is(err, model.ErrUnauthorized) {
|
|
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
|
|
}
|
|
h.writeError(w, r, err)
|
|
return
|
|
}
|
|
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), userKey, user)))
|
|
})
|
|
}
|
|
|
|
// validQuery отсекает query с битым %-экранированием: url.Values молча
|
|
// выбросил бы такой параметр, и cursor=%%% превратился бы в «с начала».
|
|
func (h *API) validQuery(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if _, err := url.ParseQuery(r.URL.RawQuery); err != nil {
|
|
h.writeError(w, r, &model.ValidationError{Message: "некорректная строка запроса"})
|
|
return
|
|
}
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func currentUser(ctx context.Context) model.User {
|
|
user, _ := ctx.Value(userKey).(model.User)
|
|
return user
|
|
}
|
|
|
|
// jsonBody читает тело POST с лимитом размера (иначе 413) и отсекает
|
|
// синтаксически неверный JSON (400) до кодогенерированного декодера: тот
|
|
// читает только первое JSON-значение и пропустил бы мусор после него.
|
|
func (h *API) jsonBody(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
next.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
reader := io.Reader(r.Body)
|
|
if h.limits.MaxBodyBytes > 0 {
|
|
reader = http.MaxBytesReader(w, r.Body, h.limits.MaxBodyBytes)
|
|
}
|
|
body, err := io.ReadAll(reader)
|
|
var tooLarge *http.MaxBytesError
|
|
switch {
|
|
case errors.As(err, &tooLarge):
|
|
h.writeError(w, r, errPayloadTooLarge)
|
|
return
|
|
case err != nil:
|
|
h.writeError(w, r, &model.ValidationError{Message: "тело запроса не прочитано"})
|
|
return
|
|
case !utf8.Valid(body)||!json.Valid(body):
|
|
h.writeError(w, r, &model.ValidationError{Message: "некорректный JSON"})
|
|
return
|
|
}
|
|
r.Body = io.NopCloser(bytes.NewReader(body))
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|