package httpapi import ( "context" "log/slog" "net/http" "sync/atomic" "time" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/propagation" semconv "go.opentelemetry.io/otel/semconv/v1.34.0" "go.opentelemetry.io/otel/trace" "gitea.privcloud.tech/dizi/mtusi2026lab7/internal/telemetry" ) type Dependencies struct { Users UserRepository Chats ChatRepository Messages MessageRepository Attachments AttachmentService Sessions SessionStore Passwords PasswordService LoginLimiter LoginLimiter Database HealthChecker Objects HealthChecker Meter metric.Meter Metrics http.Handler } type Config struct { SessionTTL time.Duration IdempotencyTTL time.Duration RequestTTL time.Duration InstanceID string SwaggerPort string } type Server struct { userRepository UserRepository chatRepository ChatRepository messageRepository MessageRepository attachments AttachmentService sessions SessionStore passwords PasswordService loginLimiter LoginLimiter database HealthChecker objects HealthChecker sessionTTL time.Duration idempotencyTTL time.Duration requestTTL time.Duration instanceID string 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, dependencies Dependencies, config Config, ) *Server { s := &Server{ userRepository: dependencies.Users, chatRepository: dependencies.Chats, messageRepository: dependencies.Messages, attachments: dependencies.Attachments, sessions: dependencies.Sessions, passwords: dependencies.Passwords, loginLimiter: dependencies.LoginLimiter, database: dependencies.Database, objects: dependencies.Objects, sessionTTL: config.SessionTTL, idempotencyTTL: config.IdempotencyTTL, requestTTL: config.RequestTTL, instanceID: config.InstanceID, logger: logger, swaggerPort: config.SwaggerPort, metrics: newMetrics(dependencies.Meter, dependencies.Metrics), } 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) HealthHandler() http.Handler { mux := http.NewServeMux() mux.HandleFunc("/health/live", func(w http.ResponseWriter, r *http.Request) { s.serveHealth(w, r, s.live) }) mux.HandleFunc("/health/ready", func(w http.ResponseWriter, r *http.Request) { s.serveHealth(w, r, s.readiness) }) return mux } func (s *Server) MetricsHandler() http.Handler { mux := http.NewServeMux() mux.Handle("/metrics", s.metrics.handler) return mux } func (s *Server) serveHealth(w http.ResponseWriter, r *http.Request, handler requestHandler) { w.Header().Set("X-Instance-Id", s.instanceID) if err := handler(w, r); err != nil { writeError(w, "", err) } } func (s *Server) serve(w http.ResponseWriter, r *http.Request) { requestContext := telemetry.Extract(r.Context(), propagation.HeaderCarrier(r.Header)) tracer := otel.Tracer("messenger-api/http") route := routeTemplate(r.URL.Path) requestContext, span := tracer.Start(requestContext, r.Method+" "+route, trace.WithSpanKind(trace.SpanKindServer), trace.WithAttributes(semconv.HTTPRequestMethodKey.String(r.Method), semconv.HTTPRoute(route))) defer span.End() r = r.WithContext(requestContext) w.Header().Set("X-Instance-Id", s.instanceID) requestID, err := newID() if err != nil { http.Error(w, "server unavailable", http.StatusServiceUnavailable) return } span.SetAttributes(attribute.String("request.id", requestID)) 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.Add(r.Context(), 1) defer func() { s.metrics.inFlight.Add(r.Context(), -1) if recovered := recover(); recovered != nil { s.logger.ErrorContext(r.Context(), "request panic", "event", "http_request_panic", "request_id", requestID, "method", r.Method, "route", route) if wrapped.status == http.StatusOK { writeError(wrapped, requestID, internalError()) } } s.metrics.observe(r.Context(), r, wrapped.status, started) span.SetAttributes(semconv.HTTPResponseStatusCode(wrapped.status)) if wrapped.status >= http.StatusInternalServerError { span.SetStatus(codes.Error, http.StatusText(wrapped.status)) } s.logger.InfoContext(r.Context(), "request", "event", "http_request_completed", "request_id", requestID, "method", r.Method, "route", route, "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, DELETE, OPTIONS") wrapped.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, Idempotency-Key") 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 { wrapped.Header().Set("WWW-Authenticate", authenticationChallenge(r)) } if apiErr.status == http.StatusTooManyRequests && wrapped.Header().Get("Retry-After") == "" { wrapped.Header().Set("Retry-After", "1") } 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, X-Instance-Id") w.Header().Add("Vary", "Origin") return true }