Add basic webserver skeleton with healthcheck

internal/server/http.go

@@ -0,0 +1,33 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func (s *Server) serveUntilShutdown() {
+	listenAddr := fmt.Sprintf(":%d", s.config.Port)
+	s.httpServer = &http.Server{
+		Addr:           listenAddr,
+		ReadTimeout:    30 * time.Second,
+		WriteTimeout:   60 * time.Second,
+		MaxHeaderBytes: 1 << 13, // 8KB
+		Handler:        s,
+	}
+
+	s.SetupRoutes()
+
+	s.log.Info("http begin listen", "listenaddr", listenAddr)
+	if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		s.log.Error("listen error", "error", err)
+		if s.cancelFunc != nil {
+			s.cancelFunc()
+		}
+	}
+}
+
+// ServeHTTP implements http.Handler.
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.router.ServeHTTP(w, r)
+}

internal/server/routes.go

@@ -0,0 +1,53 @@
+package server
+
+import (
+	"net/http"
+	"time"
+
+	sentryhttp "github.com/getsentry/sentry-go/http"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+// SetupRoutes configures all HTTP routes.
+func (s *Server) SetupRoutes() {
+	s.router = chi.NewRouter()
+
+	s.router.Use(middleware.Recoverer)
+	s.router.Use(middleware.RequestID)
+	s.router.Use(s.mw.Logging())
+
+	// Add metrics middleware only if credentials are configured
+	if s.config.MetricsUsername != "" {
+		s.router.Use(s.mw.Metrics())
+	}
+
+	s.router.Use(s.mw.CORS())
+	s.router.Use(middleware.Timeout(60 * time.Second))
+
+	if s.sentryEnabled {
+		sentryHandler := sentryhttp.New(sentryhttp.Options{
+			Repanic: true,
+		})
+		s.router.Use(sentryHandler.Handle)
+	}
+
+	// Health check endpoint
+	s.router.Get("/.well-known/healthcheck.json", s.h.HandleHealthCheck())
+
+	// Robots.txt
+	s.router.Get("/robots.txt", s.h.HandleRobotsTxt())
+
+	// Main image proxy route
+	// /v1/image/<host>/<path>/<width>x<height>.<format>
+	s.router.Get("/v1/image/*", s.h.HandleImage())
+
+	// Metrics endpoint with auth
+	if s.config.MetricsUsername != "" {
+		s.router.Group(func(r chi.Router) {
+			r.Use(s.mw.MetricsAuth())
+			r.Get("/metrics", http.HandlerFunc(promhttp.Handler().ServeHTTP))
+		})
+	}
+}

internal/server/server.go

@@ -0,0 +1,145 @@
+// Package server provides the HTTP server and lifecycle management.
+package server
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/go-chi/chi/v5"
+	"go.uber.org/fx"
+	"sneak.berlin/go/pixa/internal/config"
+	"sneak.berlin/go/pixa/internal/globals"
+	"sneak.berlin/go/pixa/internal/handlers"
+	"sneak.berlin/go/pixa/internal/logger"
+	"sneak.berlin/go/pixa/internal/middleware"
+)
+
+// ServerParams defines dependencies for Server.
+type ServerParams struct {
+	fx.In
+	Logger     *logger.Logger
+	Globals    *globals.Globals
+	Config     *config.Config
+	Middleware *middleware.Middleware
+	Handlers   *handlers.Handlers
+}
+
+// Server is the main HTTP server.
+type Server struct {
+	log           *slog.Logger
+	config        *config.Config
+	globals       *globals.Globals
+	mw            *middleware.Middleware
+	h             *handlers.Handlers
+	startupTime   time.Time
+	exitCode      int
+	sentryEnabled bool
+	ctx           context.Context
+	cancelFunc    context.CancelFunc
+	httpServer    *http.Server
+	router        *chi.Mux
+}
+
+// New creates a new Server instance.
+func New(lc fx.Lifecycle, params ServerParams) (*Server, error) {
+	s := &Server{
+		log:     params.Logger.Get(),
+		config:  params.Config,
+		globals: params.Globals,
+		mw:      params.Middleware,
+		h:       params.Handlers,
+	}
+
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			s.startupTime = time.Now()
+			go s.Run()
+
+			return nil
+		},
+		OnStop: func(ctx context.Context) error {
+			if s.cancelFunc != nil {
+				s.cancelFunc()
+			}
+
+			return nil
+		},
+	})
+
+	return s, nil
+}
+
+// Run starts the server.
+func (s *Server) Run() {
+	s.enableSentry()
+	s.serve()
+}
+
+func (s *Server) enableSentry() {
+	s.sentryEnabled = false
+
+	if s.config.SentryDSN == "" {
+		return
+	}
+
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:     s.config.SentryDSN,
+		Release: fmt.Sprintf("%s-%s", s.globals.Appname, s.globals.Version),
+	})
+	if err != nil {
+		s.log.Error("sentry init failure", "error", err)
+		os.Exit(1)
+	}
+	s.log.Info("sentry error reporting activated")
+	s.sentryEnabled = true
+}
+
+func (s *Server) serve() int {
+	s.ctx, s.cancelFunc = context.WithCancel(context.Background())
+
+	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Ignore(syscall.SIGPIPE)
+		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+		sig := <-c
+		s.log.Info("signal received", "signal", sig)
+		if s.cancelFunc != nil {
+			s.cancelFunc()
+		}
+	}()
+
+	go s.serveUntilShutdown()
+
+	<-s.ctx.Done()
+	s.cleanShutdown()
+
+	return s.exitCode
+}
+
+func (s *Server) cleanShutdown() {
+	s.exitCode = 0
+	ctxShutdown, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer shutdownCancel()
+
+	if s.httpServer != nil {
+		if err := s.httpServer.Shutdown(ctxShutdown); err != nil {
+			s.log.Error("server clean shutdown failed", "error", err)
+		}
+	}
+
+	if s.sentryEnabled {
+		sentry.Flush(2 * time.Second)
+	}
+}
+
+// MaintenanceMode returns whether maintenance mode is enabled.
+func (s *Server) MaintenanceMode() bool {
+	return s.config.MaintenanceMode
+}