19003173275

Committed 01 Nov 2025 09:55PM UTC coverage: 23.312% (-0.04%) from 23.355%

Build # 19003173275

Build Type

push

github

Committed by

web-flow

Commit Message

Handle graceful shutdown via context in Application (#15)

Move signal handling from HTTPServer to Application level Use context
for shutdown coordination across components HTTPServer now listens for
context cancellation instead of signals directly

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

252 of 1081 relevant lines covered (23.31%)

0.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.53

/httpserver/httpserver.go

// Package httpserver provides HTTP server functionality with middleware support.
package httpserver

import (
        "context"
        "errors"
        "fmt"
        "net/http"
        "time"

        "github.com/mishankov/platforma/log"
)

type handleGroup = HandlerGroup

// HTTPServer represents an HTTP server with middleware support and graceful shutdown.
type HTTPServer struct {
        *handleGroup
        port            string
        shutdownTimeout time.Duration
}

// 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}
}

// 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),
                ReadHeaderTimeout: 1 * time.Second,
        }

        go func() {
                log.InfoContext(ctx, "starting http server", "address", server.Addr)

                if err := server.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
                        log.ErrorContext(ctx, "HTTP server error", "error", err)
                }
                log.InfoContext(ctx, "stopped serving new connections")
        }()

        <-ctx.Done()

        shutdownCtx := context.Background()
        shutdownCtx, cancel := context.WithTimeout(shutdownCtx, s.shutdownTimeout)
        defer cancel()

        if err := server.Shutdown(shutdownCtx); err != nil {
                return fmt.Errorf("failed to gracefully shutdown HTTP server: %w", err)
        }
        log.InfoContext(ctx, "graceful shutdown completed")

        return nil
}

// Healthcheck returns health check information for the HTTP server.
func (s *HTTPServer) Healthcheck(_ context.Context) any {
        return map[string]any{
                "port": s.port,
        }
}

1	// Package httpserver provides HTTP server functionality with middleware support.
2	package httpserver
3
4	import (
5	"context"
6	"errors"
7	"fmt"
8	"net/http"
9	"time"
10
11	"github.com/mishankov/platforma/log"
12	)
13
14	type handleGroup = HandlerGroup
15
16	// HTTPServer represents an HTTP server with middleware support and graceful shutdown.
17	type HTTPServer struct {
18	*handleGroup
19	port string
20	shutdownTimeout time.Duration
21	}
22
23	// New creates a new HTTPServer instance with the specified port and shutdown timeout.
24	func New(port string, shutdownTimeout time.Duration) *HTTPServer {	1✔
25	return &HTTPServer{handleGroup: NewHandlerGroup(), port: port, shutdownTimeout: shutdownTimeout}	1✔
26	}	1✔
27
28	// Run starts the HTTP server and handles graceful shutdown on interrupt signals.
29	func (s *HTTPServer) Run(ctx context.Context) error {	×
30	server := &http.Server{	×
31	Addr: ":" + s.port,	×
32	Handler: wrapHandlerInMiddleware(s.mux, s.middlewares),	×
33	ReadHeaderTimeout: 1 * time.Second,	×
34	}	×
35		×
36	go func() {	×
37	log.InfoContext(ctx, "starting http server", "address", server.Addr)	×
38		×
39	if err := server.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {	×
40	log.ErrorContext(ctx, "HTTP server error", "error", err)	×
41	}	×
NEW 42	log.InfoContext(ctx, "stopped serving new connections")	×
43	}()
44
NEW 45	<-ctx.Done()	×
46		×
NEW 47	shutdownCtx := context.Background()	×
NEW 48	shutdownCtx, cancel := context.WithTimeout(shutdownCtx, s.shutdownTimeout)	×
NEW 49	defer cancel()	×
50		×
51	if err := server.Shutdown(shutdownCtx); err != nil {	×
52	return fmt.Errorf("failed to gracefully shutdown HTTP server: %w", err)	×
53	}	×
NEW 54	log.InfoContext(ctx, "graceful shutdown completed")	×
55		×
56	return nil	×
57	}
58
59	// Healthcheck returns health check information for the HTTP server.
60	func (s *HTTPServer) Healthcheck(_ context.Context) any {	1✔
61	return map[string]any{	1✔
62	"port": s.port,	1✔
63	}	1✔
64	}	1✔

mishankov / platforma / 19003173275

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous