19003144020

Committed 01 Nov 2025 09:49PM UTC coverage: 22.757% (-0.6%) from 23.355%

Build # 19003144020

Build Type

Pull #15

github

Committed by

mishankov

Commit Message

Handle graceful shutdown via context in Application

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

Pull Request Pull Request #15: Handle graceful shutdown via context in Application

Run Details

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

6 existing lines in 1 file now uncovered.

246 of 1081 relevant lines covered (22.76%)

0.26 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 / 19003144020

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