Httpserver cleanup

.golangci.yml

@@ -61,8 +61,11 @@ linters:
         rules:
           json: camel
   exclusions:
+    paths:
+      - demo-app
+
     rules:
-      - path-except: "database/*"
+      - path-except: "(database|httpserver)/*"
         linters:
           - revive
 

Taskfile.dist.yml

@@ -11,14 +11,9 @@ tasks:
 
   test:
     cmds:
-      - go test -cover -v ./...
+      - go test -cover ./...
 
   check:
     deps:
       - lint
       - test
-
-  demo:
-    dir: demo-app
-    cmds:
-      - go run ./cmd/clock/main.go

application/application.go

@@ -92,7 +92,7 @@ func (a *Application) Run(ctx context.Context) error {
 		ctx = context.Background()
 	}
 
-	log.InfoContext(ctx, "Starting application", "startupTasks", len(a.startupTasks))
+	log.InfoContext(ctx, "starting application", "startupTasks", len(a.startupTasks))
 
 	for dbName, db := range a.databases {
 		log.InfoContext(ctx, "migrating database", "database", dbName)

demo-app/cmd/api/main.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/mishankov/platforma/application"
+	"github.com/mishankov/platforma/httpserver"
+	"github.com/mishankov/platforma/log"
+)
+
+func main() {
+	ctx := context.Background()
+
+	// Initialize new application
+	app := application.New()
+
+	// Create HTTP server
+	api := httpserver.New("8080", 3*time.Second)
+
+	// Add /ping endpoint to `api`
+	api.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("pong"))
+	})
+
+	// Add /long endpoint to HTTP server to test graceful shutdown
+	api.HandleFunc("/long", func(w http.ResponseWriter, r *http.Request) {
+		time.Sleep(10 * time.Second)
+		w.Write([]byte("pong"))
+	})
+
+	// Add middleware to HTTP server. It will add trace ID to logs and responce headers
+	api.Use(httpserver.NewTraceIDMiddleware(nil, ""))
+
+	// Create handler group
+	subApiGroup := httpserver.NewHandlerGroup()
+
+	// Add /clock endpoint to handler group
+	subApiGroup.HandleFunc("/clock", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(time.Now().String()))
+	})
+
+	// Add middleware to HTTP server. It will log all incoming requests to this handle group
+	subApiGroup.UseFunc(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			log.InfoContext(r.Context(), "incoming request", "addr", r.RemoteAddr)
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	// Add handle group to HTTP server with /subApi path
+	api.HandleGroup("/subApi", subApiGroup)
+
+	// Register HTTP server as application server
+	app.RegisterService("api", api)
+
+	// Run application
+	if err := app.Run(ctx); err != nil {
+		log.ErrorContext(ctx, "app finished with error", "error", err)
+	}
+
+	// Now you can access http://localhost:8080/ping, http://localhost:8080/long
+	// and http://localhost:8080/subApi/clock URLs with GET method
+}

httpserver/handlergroup.go

@@ -27,18 +27,21 @@ func (hg *HandlerGroup) UseFunc(middlewareFuncs ...func(http.Handler) http.Handl
 	}
 }
 
-// Handle registers an http.Handler for the given pattern, applying all
-// middlewares in the HandlerGroup's chain.
+// Handle registers an http.Handler for the given pattern
 func (hg *HandlerGroup) Handle(pattern string, handler http.Handler) {
 	hg.mux.Handle(pattern, handler)
 }
 
-// HandleFunc registers an http.HandlerFunc for the given pattern, applying all
-// middlewares in the HandlerGroup's chain.
+// HandleFunc registers an http.HandlerFunc for the given pattern
 func (hg *HandlerGroup) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
 	hg.mux.Handle(pattern, http.HandlerFunc(handler))
 }
 
+// HandleGroup applies `http.StripPrefix` to http.Handler and registers it for the given pattern
+func (hg *HandlerGroup) HandleGroup(pattern string, handler http.Handler) {
+	hg.mux.Handle(pattern+"/", http.StripPrefix(pattern, handler))
+}
+
 // ServeHTTP implements the http.Handler interface, allowing HandlerGroup to
 // be used as an HTTP handler itself.
 func (hg *HandlerGroup) ServeHTTP(w http.ResponseWriter, r *http.Request) {

httpserver/httpserver.go

@@ -1,3 +1,4 @@
+// Package httpserver provides HTTP server functionality with middleware support.
 package httpserver
 
 import (
@@ -13,40 +14,22 @@ import (
 	"github.com/mishankov/platforma/log"
 )
 
-type HttpServer struct {
-	mux             *http.ServeMux
+type handleGroup = HandlerGroup
+
+// HTTPServer represents an HTTP server with middleware support and graceful shutdown.
+type HTTPServer struct {
+	*handleGroup
 	port            string
 	shutdownTimeout time.Duration
-	middlewares     []Middleware
-}
-
-func New(port string, shutdownTimeout time.Duration) *HttpServer {
-	return &HttpServer{mux: http.NewServeMux(), port: port, shutdownTimeout: shutdownTimeout}
-}
-
-func (s *HttpServer) Handle(pattern string, handler http.Handler) {
-	s.mux.Handle(pattern, handler)
-}
-
-func (s *HttpServer) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
-	s.mux.HandleFunc(pattern, http.HandlerFunc(handler))
-}
-
-func (s *HttpServer) HandleGroup(pattern string, handler http.Handler) {
-	s.mux.Handle(pattern+"/", http.StripPrefix(pattern, handler))
 }
 
-func (s *HttpServer) Use(middlewares ...Middleware) {
-	s.middlewares = append(s.middlewares, middlewares...)
-}
-
-func (s *HttpServer) UseFunc(middlewareFuncs ...func(http.Handler) http.Handler) {
-	for _, middlewareFunc := range middlewareFuncs {
-		s.middlewares = append(s.middlewares, MiddlewareFunc(middlewareFunc))
-	}
+// New creates a new HTTPServer instance with the specified port and shutdown timeout.
+func New(port string, shutdownTimeout time.Duration) *HTTPServer {
+	return &HTTPServer{handleGroup: NewHandlerGroup(), port: port, shutdownTimeout: shutdownTimeout}
 }
 
-func (s *HttpServer) Run(ctx context.Context) error {
+// Run starts the HTTP server and handles graceful shutdown on interrupt signals.
+func (s *HTTPServer) Run(ctx context.Context) error {
 	server := &http.Server{
 		Addr:              ":" + s.port,
 		Handler:           wrapHandlerInMiddleware(s.mux, s.middlewares),
@@ -70,15 +53,15 @@ func (s *HttpServer) Run(ctx context.Context) error {
 	defer shutdownRelease()
 
 	if err := server.Shutdown(shutdownCtx); err != nil {
-		log.ErrorContext(ctx, "HTTP shutdown error", "error", err)
-		return fmt.Errorf("failed to shutdown server: %w", err)
+		return fmt.Errorf("failed to gracefully shutdown HTTP server: %w", err)
 	}
 	log.InfoContext(ctx, "graceful shutdown completed.")
 
 	return nil
 }
 
-func (s *HttpServer) Healthcheck(ctx context.Context) any {
+// Healthcheck returns health check information for the HTTP server.
+func (s *HTTPServer) Healthcheck(_ context.Context) any {
 	return map[string]any{
 		"port": s.port,
 	}