cleanups and code fixes incl templ

server/server.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"syscall"
 	"time"
 
 	"github.com/go-co-op/gocron/v2"
@@ -18,6 +19,7 @@ type Server struct {
 	logger          *slog.Logger
 	cron            gocron.Scheduler
 	cancel          context.CancelFunc
+	startErr        chan error
 	disableTls      bool
 	tlsCertFilename string
 	tlsKeyFilename  string
@@ -29,33 +31,26 @@ func New(logger *slog.Logger, cron gocron.Scheduler, cancel context.CancelFunc,
 
 	// Set some options for TLS
 	tlsConfig := &tls.Config{
-		MinVersion:               tls.VersionTLS12,
-		CurvePreferences:         []tls.CurveID{tls.CurveP521, tls.CurveP384, tls.CurveP256},
-		PreferServerCipherSuites: true,
-		InsecureSkipVerify:       true,
-		CipherSuites: []uint16{
-			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-			tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_RSA_WITH_AES_256_CBC_SHA,
-		},
+		MinVersion: tls.VersionTLS12,
 	}
 
 	srv := &http.Server{
-		Addr: addr,
-		//WriteTimeout: 120 * time.Second,
-		WriteTimeout: 0,
-		ReadTimeout:  30 * time.Second,
-		TLSConfig:    tlsConfig,
-		TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
+		Addr:              addr,
+		WriteTimeout:      2 * time.Minute,
+		ReadTimeout:       30 * time.Second,
+		ReadHeaderTimeout: 10 * time.Second,
+		IdleTimeout:       120 * time.Second,
+		TLSConfig:         tlsConfig,
+		TLSNextProto:      make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
 	}
 
 	// Set the initial server values
 	server := &Server{
-		srv:    srv,
-		logger: logger,
-		cron:   cron,
-		cancel: cancel,
+		srv:      srv,
+		logger:   logger,
+		cron:     cron,
+		cancel:   cancel,
+		startErr: make(chan error, 1),
 	}
 
 	// Apply any options
@@ -120,60 +115,60 @@ func SetPrivateKey(tlsKeyFilename string) Option {
 }
 
 // StartAndWait starts the server and waits for a signal to shut down.
-func (s *Server) StartAndWait() {
+func (s *Server) StartAndWait() error {
 	s.Start()
-	s.GracefulShutdown()
+	return s.GracefulShutdown()
 }
 
 // Start starts the server.
 func (s *Server) Start() {
-
 	go func() {
 		if s.disableTls {
 			s.logger.Info("starting server", "port", s.srv.Addr)
-			if err := s.srv.ListenAndServe(); err != nil {
-				s.logger.Error("failed to start server", "error", err)
-				os.Exit(1)
+			if err := s.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+				s.startErr <- err
 			}
 		} else {
 			s.logger.Info("starting TLS server", "port", s.srv.Addr, "cert", s.tlsCertFilename, "key", s.tlsKeyFilename)
 			if err := s.srv.ListenAndServeTLS(s.tlsCertFilename, s.tlsKeyFilename); err != nil && err != http.ErrServerClosed {
-				s.logger.Error("failed to start server", "error", err)
-				os.Exit(1)
+				s.startErr <- err
 			}
 		}
 	}()
 }
 
 // GracefulShutdown shuts down the server gracefully.
-func (s *Server) GracefulShutdown() {
-	c := make(chan os.Signal, 1)
-	// We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)
-	// SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.
-	signal.Notify(c, os.Interrupt)
+func (s *Server) GracefulShutdown() error {
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt, syscall.SIGTERM)
+	defer signal.Stop(signals)
 
-	// Block until we receive our signal.
-	<-c
+	var startErr error
+	select {
+	case sig := <-signals:
+		s.logger.Info("shutdown signal received", "signal", sig.String())
 
-	// Create a deadline to wait for.
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	// Doesn't block if no connections, but will otherwise wait
-	// until the timeout deadline.
-	_ = s.srv.Shutdown(ctx)
+		// Create a deadline to wait for.
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		// Doesn't block if no connections, but will otherwise wait
+		// until the timeout deadline.
+		if err := s.srv.Shutdown(ctx); err != nil {
+			s.logger.Warn("http server shutdown returned error", "error", err)
+		}
+	case err := <-s.startErr:
+		s.logger.Error("http server exited with startup/runtime error", "error", err)
+		startErr = err
+	}
 
-	s.logger.Info("runing cron shutdown")
-	err := s.cron.Shutdown()
-	if err != nil {
+	s.logger.Info("running cron shutdown")
+	if err := s.cron.Shutdown(); err != nil {
 		s.logger.Error("error shutting cron", "error", err)
 	}
 
-	s.logger.Info("runing cancel")
+	s.logger.Info("running cancel")
 	s.cancel()
 
-	// Optionally, you could run srv.Shutdown in a goroutine and block on
-	// <-ctx.Done() if your application should wait for other services
-	// to finalize based on context cancellation.
 	s.logger.Info("shutting down")
-	//os.Exit(0)
+	return startErr
 }