Add project scaffolding with fx DI, SQLite migrations, and healthcheck

- go.mod with git.eeqj.de/sneak/chat module
- internal packages: globals, logger, config, db, healthcheck, middleware, handlers, server
- SQLite database with embedded migration system (schema_migrations tracking)
- Migration 001: schema_migrations table
- Migration 002: channels table
- Config with chat-specific vars (MAX_HISTORY, SESSION_TIMEOUT, MAX_MESSAGE_SIZE, MOTD, SERVER_NAME, FEDERATION_KEY)
- Healthcheck endpoint at /.well-known/healthcheck.json
- Makefile, .gitignore
- cmd/chatd/main.go entry point

internal/server/http.go

@@ -0,0 +1,32 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func (s *Server) serveUntilShutdown() {
+	listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
+	s.httpServer = &http.Server{
+		Addr:           listenAddr,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+		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()
+		}
+	}
+}
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.router.ServeHTTP(w, r)
+}

internal/server/routes.go

@@ -0,0 +1,45 @@
+package server
+
+import (
+	"net/http"
+	"time"
+
+	sentryhttp "github.com/getsentry/sentry-go/http"
+	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/middleware"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/spf13/viper"
+)
+
+func (s *Server) SetupRoutes() {
+	s.router = chi.NewRouter()
+
+	s.router.Use(middleware.Recoverer)
+	s.router.Use(middleware.RequestID)
+	s.router.Use(s.mw.Logging())
+
+	if viper.GetString("METRICS_USERNAME") != "" {
+		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
+	s.router.Get("/.well-known/healthcheck.json", s.h.HandleHealthCheck())
+
+	// Protected metrics endpoint
+	if viper.GetString("METRICS_USERNAME") != "" {
+		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,142 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"git.eeqj.de/sneak/chat/internal/config"
+	"git.eeqj.de/sneak/chat/internal/globals"
+	"git.eeqj.de/sneak/chat/internal/handlers"
+	"git.eeqj.de/sneak/chat/internal/logger"
+	"git.eeqj.de/sneak/chat/internal/middleware"
+	"go.uber.org/fx"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/go-chi/chi"
+
+	_ "github.com/joho/godotenv/autoload"
+)
+
+type ServerParams struct {
+	fx.In
+	Logger     *logger.Logger
+	Globals    *globals.Globals
+	Config     *config.Config
+	Middleware *middleware.Middleware
+	Handlers   *handlers.Handlers
+}
+
+type Server struct {
+	startupTime   time.Time
+	exitCode      int
+	sentryEnabled bool
+	log           *slog.Logger
+	ctx           context.Context
+	cancelFunc    context.CancelFunc
+	httpServer    *http.Server
+	router        *chi.Mux
+	params        ServerParams
+	mw            *middleware.Middleware
+	h             *handlers.Handlers
+}
+
+func New(lc fx.Lifecycle, params ServerParams) (*Server, error) {
+	s := new(Server)
+	s.params = params
+	s.mw = params.Middleware
+	s.h = params.Handlers
+	s.log = params.Logger.Get()
+
+	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 {
+			return nil
+		},
+	})
+	return s, nil
+}
+
+func (s *Server) Run() {
+	s.configure()
+	s.enableSentry()
+	s.serve()
+}
+
+func (s *Server) enableSentry() {
+	s.sentryEnabled = false
+
+	if s.params.Config.SentryDSN == "" {
+		return
+	}
+
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:     s.params.Config.SentryDSN,
+		Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.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()
+
+	for range s.ctx.Done() {
+	}
+	s.cleanShutdown()
+	return s.exitCode
+}
+
+func (s *Server) cleanupForExit() {
+	s.log.Info("cleaning up")
+}
+
+func (s *Server) cleanShutdown() {
+	s.exitCode = 0
+	ctxShutdown, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+	if err := s.httpServer.Shutdown(ctxShutdown); err != nil {
+		s.log.Error("server clean shutdown failed", "error", err)
+	}
+	if shutdownCancel != nil {
+		shutdownCancel()
+	}
+
+	s.cleanupForExit()
+
+	if s.sentryEnabled {
+		sentry.Flush(2 * time.Second)
+	}
+}
+
+func (s *Server) MaintenanceMode() bool {
+	return s.params.Config.MaintenanceMode
+}
+
+func (s *Server) configure() {
+}