18916201405

Committed 29 Oct 2025 05:08PM UTC coverage: 25.045% (+4.5%) from 20.552%

Build # 18916201405

Build Type

Pull #14

github

Committed by

mishankov

Commit Message

Add revive checks to httpserver

Pull Request Pull Request #14: Httpserver cleanup

Run Details

12 of 15 new or added lines in 4 files covered. (80.0%)

278 of 1110 relevant lines covered (25.05%)

0.28 hits per line

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

22.86

/httpserver/httpserver.go

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

import (
        "context"
        "errors"
        "fmt"
        "net/http"
        "os"
        "os/signal"
        "syscall"
        "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.")
        }()

        sigChan := make(chan os.Signal, 1)
        signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
        <-sigChan

        shutdownCtx, shutdownRelease := context.WithTimeout(ctx, s.shutdownTimeout)
        defer shutdownRelease()

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

mishankov / platforma / 18916201405

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