middleware refactors

cmd/main.go

···
 import (
 	"context"
 	"os"
+	"time"
 
 	"github.com/charmbracelet/log"
 	_ "github.com/joho/godotenv/autoload"
···
 	"tangled.org/dane.is.extraordinarily.cool/pallet/internal/db"
 	"tangled.org/dane.is.extraordinarily.cool/pallet/internal/server"
 )
-
 
 func main() {
 	if err := run(os.Args); err != nil {
···
 
 func run(args []string) error {
 	app := &cli.Command{
-		Name: "pallet",
+		Name:  "pallet",
 		Usage: "pallet app server",
 	}
 
 	app.Flags = []cli.Flag{
 		&cli.StringFlag{
-			Name: "log-level",
-			Usage: "log verbosity level (eg: warn, info, debug)",
+			Name:    "log-level",
+			Usage:   "log verbosity level (eg: warn, info, debug)",
 			Sources: cli.EnvVars("GO_LOG_LEVEL", "LOG_LEVEL"),
 		},
 	}
 
 	app.Commands = []*cli.Command{
 		&cli.Command{
-			Name: "start",
-			Usage: "start the pallet app server",
+			Name:   "start",
+			Usage:  "start the pallet app server",
 			Action: runServer,
 			Flags: []cli.Flag{
 				&cli.StringFlag{
-					Name: "port",
-					Usage: "Port to bind the HTTP server to",
-					Value: ":8080",
+					Name:    "port",
+					Usage:   "Port to bind the HTTP server to",
+					Value:   ":8080",
 					Sources: cli.EnvVars("PORT"),
 				},
 			},
 		},
 	}
-
 
 	return app.Run(context.Background(), args)
 }
 
 func runServer(ctx context.Context, cmd *cli.Command) error {
+	appContext, cancel := context.WithTimeout(ctx, time.Minute*5)
+	defer cancel()
 	logger := log.New(os.Stdout)
 	db, err := db.NewSQLiteDB()
 	if err != nil {
···
 	}
 	logger.Info("database created")
 
-	server := server.NewServer(cmd.String("port"), db, logger)
+	server := server.NewServer(appContext, cmd.String("port"), db, logger)
 
 	if err := server.Start(); err != nil {
 		log.Fatal(err)
 	}
 
 	return nil
-}
+}
+
+// func migrate(db *sql.DB) {
+// 	_, err = db.
+// }

internal/server/handlers.go

···
 import "net/http"
 
 func (s *Server) handleHomeRoute(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("hello world"))
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("hello world"))
 }
 
 func (s *Server) handleHealthCheckRoute(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(http.StatusOK);
+	w.WriteHeader(http.StatusOK)
 	w.Write([]byte("reporting for duty"))
-}
+}

internal/server/server.go

···
 package server
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"net/http"
···
 )
 
 type Server struct {
-	addr string
-	db *sql.DB
+	ctx    context.Context
+	addr   string
+	db     *sql.DB
 	logger *log.Logger
 }
 
···
 	status int
 }
 
-func NewServer(addr string, db *sql.DB, logger *log.Logger) *Server {
+func NewServer(ctx context.Context, addr string, db *sql.DB, logger *log.Logger) *Server {
 	return &Server{
+		ctx,
 		addr,
 		db,
 		logger,
···
 
 func (s *Server) Start() error {
 	router := mux.NewRouter()
+	router.Use(s.requestLoggerMiddleware)
+	router.Use(s.contextWithTimeoutMiddleware)
 	server := &http.Server{
-		Addr: s.addr,
+		Addr:         s.addr,
 		WriteTimeout: 5 * time.Second,
-		ReadTimeout: 10 * time.Second,
-		IdleTimeout: 30 * time.Second,
-		Handler: requestLoggerMiddleware(s.logger, router),
+		ReadTimeout:  10 * time.Second,
+		IdleTimeout:  30 * time.Second,
+		Handler:      router,
 	}
 
 	router.HandleFunc("/healthcheck", s.handleHomeRoute)
···
 	return server.ListenAndServe()
 }
 
-func requestLoggerMiddleware(logger *log.Logger, next http.Handler) http.Handler {
+func (s *Server) contextWithTimeoutMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx, cancel := context.WithTimeout(r.Context(), time.Second*30)
+		defer cancel()
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (s *Server) requestLoggerMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		recorder := statusRecorder{
 			ResponseWriter: w,
-			status: http.StatusOK,
+			status:         http.StatusOK,
 		}
 
 		next.ServeHTTP(recorder, r)
 		var (
-			ip = r.RemoteAddr
-			method = r.Method
-			url = r.URL.String()
-			proto = r.Proto
+			ip        = r.RemoteAddr
+			method    = r.Method
+			url       = r.URL.String()
+			proto     = r.Proto
 			timestamp = time.Now().Format(time.RFC850)
 		)
 
-
-		logger.Info(fmt.Sprintf("%s [%s] %s %s %s %d", ip, timestamp, method, url, proto, recorder.status))
+		s.logger.Info(fmt.Sprintf("%s [%s] %s %s %s %d", ip, timestamp, method, url, proto, recorder.status))
 	})
-}
+}

justfile

···
     go run cmd/*.go start
 
 build:
-    CGO_ENABLED=0 go build -o build/pallet ./cmd/main.go
+    CGO_ENABLED=1 go build -o build/pallet ./cmd/main.go
 
 clean:
-    rm -rf build
+    rm -rf build