Files
mtusi2026lab4/src/internal/api/middleware.go
T
2026-10-29 15:00:36 +03:00

151 lines
3.7 KiB
Go

package api
import (
"context"
"errors"
"log/slog"
"net/http"
"strings"
"time"
"github.com/google/uuid"
"mtusi-messenger/internal/apperr"
"mtusi-messenger/internal/auth"
"mtusi-messenger/internal/model"
)
type ctxKey int
const (
ctxRequestID ctxKey = iota
ctxUser
ctxToken
)
func requestIDMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-Id")
if id == "" {
id = uuid.NewString()
}
w.Header().Set("X-Request-Id", id)
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxRequestID, id)))
})
}
func instanceIDMiddleware(instanceID string, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", instanceID)
next.ServeHTTP(w, r)
})
}
func requestID(r *http.Request) string {
if id, ok := r.Context().Value(ctxRequestID).(string); ok && id != "" {
return id
}
return "unknown"
}
type statusWriter struct {
http.ResponseWriter
status int
}
func (s *statusWriter) WriteHeader(code int) {
s.status = code
s.ResponseWriter.WriteHeader(code)
}
func loggingMiddleware(log *slog.Logger, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
sw := &statusWriter{ResponseWriter: w, status: http.StatusOK}
next.ServeHTTP(sw, r)
log.Info("http",
"method", r.Method,
"path", r.URL.Path,
"status", sw.status,
"dur_ms", time.Since(start).Milliseconds(),
"request_id", requestID(r),
)
})
}
func recoverMiddleware(log *slog.Logger, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
log.Error("panic recovered", "path", r.URL.Path, "request_id", requestID(r))
apperr.Write(w, requestID(r), apperr.Internal("internal error"))
}
}()
next.ServeHTTP(w, r)
})
}
// Binary transfers get a longer budget than JSON requests.
func timeoutMiddleware(d, binary time.Duration, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
limit := d
if strings.Contains(r.URL.Path, "/attachments") {
limit = binary
}
ctx, cancel := context.WithTimeout(r.Context(), limit)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
const bearerChallenge = `Bearer realm="messenger"`
func unauthorizedBearer(w http.ResponseWriter, r *http.Request) {
w.Header().Set("WWW-Authenticate", bearerChallenge)
apperr.Write(w, requestID(r), apperr.Unauthorized("valid Bearer session token is required"))
}
func bearerToken(r *http.Request) (string, bool) {
scheme, token, ok := strings.Cut(r.Header.Get("Authorization"), " ")
if !ok || !strings.EqualFold(scheme, "Bearer") {
return "", false
}
token = strings.TrimSpace(token)
if token == "" || len(token) > 256 {
return "", false
}
return token, true
}
func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
token, ok := bearerToken(r)
if !ok {
unauthorizedBearer(w, r)
return
}
user, err := s.sessions.Resolve(r.Context(), token)
if errors.Is(err, auth.ErrInvalidSession) {
unauthorizedBearer(w, r)
return
}
if err != nil {
s.storeError(w, r, err)
return
}
ctx := context.WithValue(r.Context(), ctxUser, user)
ctx = context.WithValue(ctx, ctxToken, token)
next.ServeHTTP(w, r.WithContext(ctx))
}
}
func currentUser(r *http.Request) *model.User {
return r.Context().Value(ctxUser).(*model.User)
}
func currentToken(r *http.Request) string {
return r.Context().Value(ctxToken).(string)
}