12498383953

Committed 26 Dec 2024 01:45AM UTC coverage: 62.994% (+0.4%) from 62.62%

Build # 12498383953

Build Type

Pull #644

github

Committed by

mostafa

Commit Message

Fix missing log message and span

Pull Request Pull Request #644: Refactor commands

Run Details

870 of 1120 new or added lines in 11 files covered. (77.68%)

33 existing lines in 3 files now uncovered.

5231 of 8304 relevant lines covered (62.99%)

17.13 hits per line

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

57.14

/api/http_server.go

package api

import (
        "context"
        "encoding/json"
        "errors"
        "io/fs"
        "net/http"
        "time"

        v1 "github.com/gatewayd-io/gatewayd/api/v1"
        "github.com/gatewayd-io/gatewayd/config"
        "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
        "github.com/rs/zerolog"
        "google.golang.org/grpc"
        "google.golang.org/grpc/credentials/insecure"
)

const headerReadTimeout = 10 * time.Second

type Healthz struct {
        Status string `json:"status"`
}

type HTTPServer struct {
        httpServer *http.Server
        options    *Options
        logger     zerolog.Logger
}

// NewHTTPServer creates a new HTTP server.
func NewHTTPServer(options *Options) *HTTPServer {
        httpServer := createHTTPAPI(options)
        return &HTTPServer{
                httpServer: httpServer,
                options:    options,
                logger:     options.Logger,
        }
}

// Start starts the HTTP server.
func (s *HTTPServer) Start() {
        // Start HTTP server (and proxy calls to gRPC server endpoint)
        if err := s.httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
                s.options.Logger.Err(err).Msg("failed to start HTTP API")
        }
}

// Shutdown shuts down the HTTP server.
func (s *HTTPServer) Shutdown(ctx context.Context) {
        if err := s.httpServer.Shutdown(ctx); err != nil {
                s.logger.Err(err).Msg("failed to shutdown HTTP API")
        }
}

// CreateHTTPAPI creates a new HTTP API.
func createHTTPAPI(options *Options) *http.Server {
        // Register gRPC server endpoint
        // TODO: Make this configurable with TLS and Auth.
        rmux := runtime.NewServeMux()
        opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
        err := v1.RegisterGatewayDAdminAPIServiceHandlerFromEndpoint(
                context.Background(), rmux, options.GRPCAddress, opts)
        if err != nil {
                options.Logger.Err(err).Msg("failed to start HTTP API")
        }

        mux := http.NewServeMux()
        mux.Handle("/", rmux)
        mux.HandleFunc("/healthz", func(writer http.ResponseWriter, _ *http.Request) {
                if liveness(options.Servers, options.RaftNode) {
                        writer.Header().Set("Content-Type", "application/json")
                        writer.WriteHeader(http.StatusOK)
                        if err := json.NewEncoder(writer).Encode(Healthz{Status: "SERVING"}); err != nil {
                                options.Logger.Err(err).Msg("failed to serve healthcheck")
                                writer.WriteHeader(http.StatusInternalServerError)
                        }
                } else {
                        writer.Header().Set("Content-Type", "application/json")
                        writer.WriteHeader(http.StatusServiceUnavailable)
                        if err := json.NewEncoder(writer).Encode(Healthz{Status: "NOT_SERVING"}); err != nil {
                                options.Logger.Err(err).Msg("failed to serve healthcheck")
                        }
                }
        })

        mux.HandleFunc("/version", func(writer http.ResponseWriter, _ *http.Request) {
                writer.WriteHeader(http.StatusOK)
                if _, err := writer.Write([]byte(config.Version)); err != nil {
                        options.Logger.Err(err).Msg("failed to serve version")
                        writer.WriteHeader(http.StatusInternalServerError)
                }
        })

        if IsSwaggerEmbedded() {
                mux.HandleFunc("/swagger.json", func(writer http.ResponseWriter, _ *http.Request) {
                        writer.WriteHeader(http.StatusOK)
                        data, _ := swaggerUI.ReadFile("v1/api.swagger.json")
                        if _, err := writer.Write(data); err != nil {
                                options.Logger.Err(err).Msg("failed to serve swagger.json")
                                writer.WriteHeader(http.StatusInternalServerError)
                        }
                })

                fsys, err := fs.Sub(swaggerUI, "v1/swagger-ui")
                if err != nil {
                        options.Logger.Err(err).Msg("failed to serve swagger-ui")
                        return nil
                }
                mux.Handle("/swagger-ui/", http.StripPrefix("/swagger-ui/", http.FileServer(http.FS(fsys))))
        }

        server := &http.Server{
                Addr:              options.HTTPAddress,
                Handler:           mux,
                ReadHeaderTimeout: headerReadTimeout,
        }

        return server
}

1	package api
2
3	import (
4	"context"
5	"encoding/json"
6	"errors"
7	"io/fs"
8	"net/http"
9	"time"
10
11	v1 "github.com/gatewayd-io/gatewayd/api/v1"
12	"github.com/gatewayd-io/gatewayd/config"
13	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
14	"github.com/rs/zerolog"
15	"google.golang.org/grpc"
16	"google.golang.org/grpc/credentials/insecure"
17	)
18
19	const headerReadTimeout = 10 * time.Second
20
21	type Healthz struct {
22	Status string `json:"status"`
23	}
24
25	type HTTPServer struct {
26	httpServer *http.Server
27	options *Options
28	logger zerolog.Logger
29	}
30
31	// NewHTTPServer creates a new HTTP server.
32	func NewHTTPServer(options Options) HTTPServer {	1✔
33	httpServer := createHTTPAPI(options)	1✔
34	return &HTTPServer{	1✔
35	httpServer: httpServer,	1✔
36	options: options,	1✔
37	logger: options.Logger,	1✔
38	}	1✔
39	}	1✔
40
41	// Start starts the HTTP server.
42	func (s *HTTPServer) Start() {	1✔
43	// Start HTTP server (and proxy calls to gRPC server endpoint)	1✔
44	if err := s.httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {	1✔
NEW 45	s.options.Logger.Err(err).Msg("failed to start HTTP API")	×
NEW 46	}	×
47	}
48
49	// Shutdown shuts down the HTTP server.
50	func (s *HTTPServer) Shutdown(ctx context.Context) {	1✔
51	if err := s.httpServer.Shutdown(ctx); err != nil {	1✔
NEW 52	s.logger.Err(err).Msg("failed to shutdown HTTP API")	×
NEW 53	}	×
54	}
55
56	// CreateHTTPAPI creates a new HTTP API.
57	func createHTTPAPI(options Options) http.Server {	1✔
58	// Register gRPC server endpoint	1✔
59	// TODO: Make this configurable with TLS and Auth.	1✔
60	rmux := runtime.NewServeMux()	1✔
61	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}	1✔
62	err := v1.RegisterGatewayDAdminAPIServiceHandlerFromEndpoint(	1✔
63	context.Background(), rmux, options.GRPCAddress, opts)	1✔
64	if err != nil {	1✔
65	options.Logger.Err(err).Msg("failed to start HTTP API")	×
66	}	×
67
68	mux := http.NewServeMux()	1✔
69	mux.Handle("/", rmux)	1✔
70	mux.HandleFunc("/healthz", func(writer http.ResponseWriter, _ *http.Request) {	2✔
71	if liveness(options.Servers, options.RaftNode) {	1✔
72	writer.Header().Set("Content-Type", "application/json")	×
73	writer.WriteHeader(http.StatusOK)	×
74	if err := json.NewEncoder(writer).Encode(Healthz{Status: "SERVING"}); err != nil {	×
75	options.Logger.Err(err).Msg("failed to serve healthcheck")	×
76	writer.WriteHeader(http.StatusInternalServerError)	×
77	}	×
78	} else {	1✔
79	writer.Header().Set("Content-Type", "application/json")	1✔
80	writer.WriteHeader(http.StatusServiceUnavailable)	1✔
81	if err := json.NewEncoder(writer).Encode(Healthz{Status: "NOT_SERVING"}); err != nil {	1✔
82	options.Logger.Err(err).Msg("failed to serve healthcheck")	×
83	}	×
84	}
85	})
86
87	mux.HandleFunc("/version", func(writer http.ResponseWriter, _ *http.Request) {	2✔
88	writer.WriteHeader(http.StatusOK)	1✔
89	if _, err := writer.Write([]byte(config.Version)); err != nil {	1✔
90	options.Logger.Err(err).Msg("failed to serve version")	×
91	writer.WriteHeader(http.StatusInternalServerError)	×
92	}	×
93	})
94
95	if IsSwaggerEmbedded() {	1✔
96	mux.HandleFunc("/swagger.json", func(writer http.ResponseWriter, _ *http.Request) {	×
97	writer.WriteHeader(http.StatusOK)	×
98	data, _ := swaggerUI.ReadFile("v1/api.swagger.json")	×
99	if _, err := writer.Write(data); err != nil {	×
100	options.Logger.Err(err).Msg("failed to serve swagger.json")	×
101	writer.WriteHeader(http.StatusInternalServerError)	×
102	}	×
103	})
104
105	fsys, err := fs.Sub(swaggerUI, "v1/swagger-ui")	×
106	if err != nil {	×
107	options.Logger.Err(err).Msg("failed to serve swagger-ui")	×
108	return nil	×
109	}	×
110	mux.Handle("/swagger-ui/", http.StripPrefix("/swagger-ui/", http.FileServer(http.FS(fsys))))	×
111	}
112
113	server := &http.Server{	1✔
114	Addr: options.HTTPAddress,	1✔
115	Handler: mux,	1✔
116	ReadHeaderTimeout: headerReadTimeout,	1✔
117	}	1✔
118		1✔
119	return server	1✔
120	}

gatewayd-io / gatewayd / 12498383953

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