Kyle Isom
ebe2079a83
All import paths updated from git.wntrmute.dev/kyle/mcdsl to git.wntrmute.dev/mc/mcdsl to match the Gitea organization. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
122 lines
3.4 KiB
Go
122 lines
3.4 KiB
Go
// Package httpserver provides TLS HTTP server setup with chi, standard
|
|
// middleware, and graceful shutdown for Metacircular services.
|
|
package httpserver
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
|
|
"git.wntrmute.dev/mc/mcdsl/config"
|
|
)
|
|
|
|
// Server wraps a chi router and an http.Server with the standard
|
|
// Metacircular TLS configuration.
|
|
type Server struct {
|
|
// Router is the chi router. Services register their routes on it.
|
|
Router *chi.Mux
|
|
|
|
// Logger is used by the logging middleware.
|
|
Logger *slog.Logger
|
|
|
|
httpSrv *http.Server
|
|
cfg config.ServerConfig
|
|
}
|
|
|
|
// New creates a Server configured from cfg. The underlying http.Server
|
|
// is configured with TLS 1.3 minimum and timeouts from the config.
|
|
// Services access s.Router to register routes before calling
|
|
// ListenAndServeTLS.
|
|
func New(cfg config.ServerConfig, logger *slog.Logger) *Server {
|
|
r := chi.NewRouter()
|
|
|
|
s := &Server{
|
|
Router: r,
|
|
Logger: logger,
|
|
cfg: cfg,
|
|
}
|
|
|
|
s.httpSrv = &http.Server{
|
|
Addr: cfg.ListenAddr,
|
|
Handler: r,
|
|
TLSConfig: &tls.Config{
|
|
MinVersion: tls.VersionTLS13,
|
|
},
|
|
ReadTimeout: cfg.ReadTimeout.Duration,
|
|
WriteTimeout: cfg.WriteTimeout.Duration,
|
|
IdleTimeout: cfg.IdleTimeout.Duration,
|
|
}
|
|
|
|
return s
|
|
}
|
|
|
|
// ListenAndServeTLS starts the HTTPS server using the TLS certificate and
|
|
// key from the config. It blocks until the server is shut down. Returns
|
|
// nil if the server was shut down gracefully via [Server.Shutdown].
|
|
func (s *Server) ListenAndServeTLS() error {
|
|
s.Logger.Info("starting server", "addr", s.cfg.ListenAddr)
|
|
err := s.httpSrv.ListenAndServeTLS(s.cfg.TLSCert, s.cfg.TLSKey)
|
|
if err != nil && err != http.ErrServerClosed {
|
|
return fmt.Errorf("httpserver: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Shutdown gracefully shuts down the server, waiting for in-flight
|
|
// requests to complete. The provided context controls the shutdown
|
|
// timeout.
|
|
func (s *Server) Shutdown(ctx context.Context) error {
|
|
return s.httpSrv.Shutdown(ctx)
|
|
}
|
|
|
|
// LoggingMiddleware logs each HTTP request after it completes, including
|
|
// method, path, status code, duration, and remote address.
|
|
func (s *Server) LoggingMiddleware(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)
|
|
s.Logger.Info("http",
|
|
"method", r.Method,
|
|
"path", r.URL.Path,
|
|
"status", sw.Status,
|
|
"duration", time.Since(start),
|
|
"remote", r.RemoteAddr,
|
|
)
|
|
})
|
|
}
|
|
|
|
// StatusWriter wraps an http.ResponseWriter to capture the status code.
|
|
// It is exported for use in custom middleware.
|
|
type StatusWriter struct {
|
|
http.ResponseWriter
|
|
// Status is the HTTP status code written to the response.
|
|
Status int
|
|
}
|
|
|
|
// WriteHeader captures the status code and delegates to the underlying
|
|
// ResponseWriter.
|
|
func (w *StatusWriter) WriteHeader(code int) {
|
|
w.Status = code
|
|
w.ResponseWriter.WriteHeader(code)
|
|
}
|
|
|
|
// WriteJSON writes v as JSON with the given HTTP status code.
|
|
func WriteJSON(w http.ResponseWriter, status int, v any) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(status)
|
|
_ = json.NewEncoder(w).Encode(v)
|
|
}
|
|
|
|
// WriteError writes a standard Metacircular error response:
|
|
// {"error": "message"}.
|
|
func WriteError(w http.ResponseWriter, status int, message string) {
|
|
WriteJSON(w, status, map[string]string{"error": message})
|
|
}
|