forked from mtusi2026/mtusi2026lab2
103 lines
3.1 KiB
Go
103 lines
3.1 KiB
Go
package messenger
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"net/http"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
type Server struct {
|
|
repository Repository
|
|
sessions SessionStore
|
|
passwords Passwords
|
|
sessionTTL time.Duration
|
|
requestTTL time.Duration
|
|
logger *slog.Logger
|
|
swaggerPort string
|
|
metrics *metrics
|
|
ready atomic.Bool
|
|
}
|
|
|
|
type statusWriter struct {
|
|
http.ResponseWriter
|
|
status int
|
|
}
|
|
|
|
func (w *statusWriter) WriteHeader(status int) {
|
|
w.status = status
|
|
w.ResponseWriter.WriteHeader(status)
|
|
}
|
|
|
|
func NewServer(logger *slog.Logger, repository Repository, sessions SessionStore, passwords Passwords, sessionTTL, requestTTL time.Duration, swaggerPort string) *Server {
|
|
s := &Server{
|
|
repository: repository, sessions: sessions, passwords: passwords,
|
|
sessionTTL: sessionTTL, requestTTL: requestTTL, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(),
|
|
}
|
|
s.ready.Store(true)
|
|
return s
|
|
}
|
|
|
|
func (s *Server) SetReady(ready bool) {
|
|
s.ready.Store(ready)
|
|
}
|
|
|
|
func (s *Server) Handler() http.Handler {
|
|
return http.HandlerFunc(s.serve)
|
|
}
|
|
|
|
func (s *Server) serve(w http.ResponseWriter, r *http.Request) {
|
|
requestID, err := newID()
|
|
if err != nil {
|
|
http.Error(w, "server unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
w.Header().Set("X-Request-Id", requestID)
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
wrapped := &statusWriter{ResponseWriter: w, status: http.StatusOK}
|
|
started := time.Now()
|
|
s.metrics.inFlight.Inc()
|
|
defer func() {
|
|
s.metrics.inFlight.Dec()
|
|
if recovered := recover(); recovered != nil {
|
|
s.logger.Error("request panic", "request_id", requestID, "method", r.Method, "path", r.URL.Path)
|
|
if wrapped.status == http.StatusOK {
|
|
writeError(wrapped, requestID, internalError())
|
|
}
|
|
}
|
|
s.metrics.observe(r, wrapped.status, started)
|
|
s.logger.Info("request", "request_id", requestID, "method", r.Method, "path", r.URL.Path, "status", wrapped.status, "duration_ms", time.Since(started).Milliseconds())
|
|
}()
|
|
if s.allowSwaggerOrigin(wrapped, r) && r.Method == http.MethodOptions && r.Header.Get("Access-Control-Request-Method") != "" {
|
|
wrapped.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
|
|
wrapped.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
|
|
wrapped.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}
|
|
ctx, cancel := context.WithTimeout(r.Context(), s.requestTTL)
|
|
defer cancel()
|
|
r = r.WithContext(ctx)
|
|
if apiErr := s.route(wrapped, r); apiErr != nil {
|
|
if apiErr.status == http.StatusUnauthorized {
|
|
challenge := `Bearer realm="messenger"`
|
|
if r.URL.Path == "/api/v1/auth/sessions" {
|
|
challenge = `Basic realm="messenger", charset="UTF-8"`
|
|
}
|
|
wrapped.Header().Set("WWW-Authenticate", challenge)
|
|
}
|
|
writeError(wrapped, requestID, apiErr)
|
|
}
|
|
}
|
|
|
|
func (s *Server) allowSwaggerOrigin(w http.ResponseWriter, r *http.Request) bool {
|
|
origin := r.Header.Get("Origin")
|
|
if origin != "http://localhost:"+s.swaggerPort && origin != "http://127.0.0.1:"+s.swaggerPort {
|
|
return false
|
|
}
|
|
w.Header().Set("Access-Control-Allow-Origin", origin)
|
|
w.Header().Set("Access-Control-Expose-Headers", "X-Request-Id")
|
|
w.Header().Add("Vary", "Origin")
|
|
return true
|
|
}
|