106462226

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/maruina/go-infrabin/commit/<a class=hub.com/maruina/go-infrabin/commit/ccfbc8d81b8b4c2b22bb7cb6fe1b5b17e82fa6c9">ccfbc8d81<a href="https://github.com/maruina/go-infrabin/commit/ccfbc8d81b8b4c2b22bb7cb6fe1b5b17e82fa6c9">">Merge </a><a class="double-link" href="https://github.com/maruina/go-infrabin/commit/<a class="double-link" href="https://github.com/maruina/go-infrabin/commit/190f53608426d3db4cded9059267c3d78cab2c8f">190f53608</a>">190f53608</a><a href="https://github.com/maruina/go-infrabin/commit/ccfbc8d81b8b4c2b22bb7cb6fe1b5b17e82fa6c9"> into 0ea35cb5a">0ea35cb5a</a>

Pull Request Pull Request #23: Support failing root handler on env var

Run Details

23 of 23 new or added lines in 1 file covered. (100.0%)

97 of 156 relevant lines covered (62.18%)

0.94 hits per line

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

60.0

/cmd/go-infrabin/main.go

package main

import (
        "io"
        "log"
        "net/http"
        "os"
        "strconv"
        "time"

        "github.com/gorilla/mux"
        helpers "github.com/maruina/go-infrabin/internal/helpers"
)

// RootHandler handles the "/" endpoint
func RootHandler(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")

        fail := helpers.GetEnv("FAIL_ROOT_HANDLER", "")
        if fail != "" {
                w.WriteHeader(http.StatusServiceUnavailable)
        } else {
                w.WriteHeader(http.StatusOK)

                hostname, err := os.Hostname()
                if err != nil {
                        log.Fatalf("cannot get hostname: %v", err)
                }

                var resp helpers.Response
                resp.Hostname = hostname
                resp.KubeResponse = &helpers.KubeResponse{
                        PodName:   helpers.GetEnv("POD_NAME", ""),
                        Namespace: helpers.GetEnv("POD_NAMESPACE", ""),
                        PodIP:     helpers.GetEnv("POD_IP", ""),
                        NodeName:  helpers.GetEnv("NODE_NAME", ""),
                }

                data := helpers.MarshalResponseToString(resp)
                _, err = io.WriteString(w, data)
                if err != nil {
                        log.Fatal("error writing to ResponseWriter: ", err)
                }
        }
}

// LivenessHandler handles the "/liveness" endpoint
func LivenessHandler(w http.ResponseWriter, r *http.Request) {
        var resp helpers.Response
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        resp.Liveness = "pass"
        data := helpers.MarshalResponseToString(resp)
        _, err := io.WriteString(w, data)
        if err != nil {
                log.Fatal("error writing to ResponseWriter", err)
        }
}

// DelayHandler handles the "/delay" endpoint
func DelayHandler(w http.ResponseWriter, r *http.Request) {
        var resp helpers.Response
        var seconds int
        vars := mux.Vars(r)
        w.Header().Set("Content-Type", "application/json")

        seconds, err := strconv.Atoi(vars["seconds"])
        if err != nil {
                resp.Error = "cannot convert seconds to integer"
                data := helpers.MarshalResponseToString(resp)
                w.WriteHeader(http.StatusBadRequest)
                _, err = io.WriteString(w, data)
                if err != nil {
                        log.Fatal("error writing to ResponseWriter", err)
                }
        } else {
                maxDelay, err := strconv.Atoi(helpers.GetEnv("INFRABIN_MAX_DELAY", "120"))
                if err != nil {
                        log.Fatalf("cannot convert env var INFRABIN_MAX_DELAY to integer: %v", err)
                }
                time.Sleep(time.Duration(helpers.Min(seconds, maxDelay)) * time.Second)

                resp.Delay = strconv.Itoa(seconds)
                data := helpers.MarshalResponseToString(resp)

                w.WriteHeader(http.StatusOK)
                _, err = io.WriteString(w, data)
                if err != nil {
                        log.Fatal("error writing to ResponseWriter", err)
                }
        }
}

// HeadersHandler handles the headers endpoint
func HeadersHandler(w http.ResponseWriter, r *http.Request) {
        var resp helpers.Response
        w.Header().Set("Content-Type", "application/json")
        resp.Headers = &r.Header

        data := helpers.MarshalResponseToString(resp)
        _, err := io.WriteString(w, data)
        if err != nil {
                log.Fatal("error writing to ResponseWriter: ", err)
        }
}

// EnvHandler handles the env endpoint
func EnvHandler(w http.ResponseWriter, r *http.Request) {
        var resp helpers.Response
        vars := mux.Vars(r)
        w.Header().Set("Content-Type", "application/json")
        value := helpers.GetEnv(vars["env_var"], "")

        if value == "" {
                data := helpers.MarshalResponseToString(resp)
                w.WriteHeader(http.StatusNotFound)
                _, err := io.WriteString(w, data)
                if err != nil {
                        log.Fatal("error writing to ResponseWriter", err)
                }
        } else {

                resp.Env = map[string]string{
                        vars["env_var"]: value,
                }
                data := helpers.MarshalResponseToString(resp)

                w.WriteHeader(http.StatusOK)
                _, err := io.WriteString(w, data)
                if err != nil {
                        log.Fatal("error writing to ResponseWriter", err)
                }

        }
}

func main() {
        r := mux.NewRouter()
        a := mux.NewRouter()
        finish := make(chan bool)

        r.HandleFunc("/", RootHandler)
        r.HandleFunc("/delay/{seconds}", DelayHandler)
        r.HandleFunc("/headers", HeadersHandler)
        r.HandleFunc("/env/{env_var}", EnvHandler)

        a.HandleFunc("/liveness", LivenessHandler)

        serviceSrv := &http.Server{
                Handler: r,
                Addr:    "0.0.0.0:8888",
                // Good practice: enforce timeouts
                WriteTimeout: 15 * time.Second,
                ReadTimeout:  15 * time.Second,
        }
        adminSrv := &http.Server{
                Handler: a,
                Addr:    "0.0.0.0:8899",
                // Good practice: enforce timeouts
                WriteTimeout: 15 * time.Second,
                ReadTimeout:  15 * time.Second,
        }

        log.Print("starting go-infrabin")

        go func() {
                log.Print("Listening on service port 8888...")
                log.Fatal(serviceSrv.ListenAndServe())
        }()

        go func() {
                log.Print("Listening on admin port 8899...")
                log.Fatal(adminSrv.ListenAndServe())
        }()
        <-finish
}

1	package main
2
3	import (
4	"io"
5	"log"
6	"net/http"
7	"os"
8	"strconv"
9	"time"
10
11	"github.com/gorilla/mux"
12	helpers "github.com/maruina/go-infrabin/internal/helpers"
13	)
14
15	// RootHandler handles the "/" endpoint
16	func RootHandler(w http.ResponseWriter, r *http.Request) {	3✔
17	w.Header().Set("Content-Type", "application/json")	3✔
18		3✔
19	fail := helpers.GetEnv("FAIL_ROOT_HANDLER", "")	3✔
20	if fail != "" {	4✔
21	w.WriteHeader(http.StatusServiceUnavailable)	1✔
22	} else {	3✔
23	w.WriteHeader(http.StatusOK)	2✔
24		2✔
25	hostname, err := os.Hostname()	2✔
26	if err != nil {	2✔
27	log.Fatalf("cannot get hostname: %v", err)	×
28	}	×
29
30	var resp helpers.Response	2✔
31	resp.Hostname = hostname	2✔
32	resp.KubeResponse = &helpers.KubeResponse{	2✔
33	PodName: helpers.GetEnv("POD_NAME", ""),	2✔
34	Namespace: helpers.GetEnv("POD_NAMESPACE", ""),	2✔
35	PodIP: helpers.GetEnv("POD_IP", ""),	2✔
36	NodeName: helpers.GetEnv("NODE_NAME", ""),	2✔
37	}	2✔
38		2✔
39	data := helpers.MarshalResponseToString(resp)	2✔
40	_, err = io.WriteString(w, data)	2✔
41	if err != nil {	2✔
42	log.Fatal("error writing to ResponseWriter: ", err)	×
43	}	×
44	}
45	}
46
47	// LivenessHandler handles the "/liveness" endpoint
48	func LivenessHandler(w http.ResponseWriter, r *http.Request) {	1✔
49	var resp helpers.Response	1✔
50	w.Header().Set("Content-Type", "application/json")	1✔
51	w.WriteHeader(http.StatusOK)	1✔
52	resp.Liveness = "pass"	1✔
53	data := helpers.MarshalResponseToString(resp)	1✔
54	_, err := io.WriteString(w, data)	1✔
55	if err != nil {	1✔
56	log.Fatal("error writing to ResponseWriter", err)	×
57	}	×
58	}
59
60	// DelayHandler handles the "/delay" endpoint
61	func DelayHandler(w http.ResponseWriter, r *http.Request) {	2✔
62	var resp helpers.Response	2✔
63	var seconds int	2✔
64	vars := mux.Vars(r)	2✔
65	w.Header().Set("Content-Type", "application/json")	2✔
66		2✔
67	seconds, err := strconv.Atoi(vars["seconds"])	2✔
68	if err != nil {	3✔
69	resp.Error = "cannot convert seconds to integer"	1✔
70	data := helpers.MarshalResponseToString(resp)	1✔
71	w.WriteHeader(http.StatusBadRequest)	1✔
72	_, err = io.WriteString(w, data)	1✔
73	if err != nil {	1✔
74	log.Fatal("error writing to ResponseWriter", err)	×
75	}	×
76	} else {	1✔
77	maxDelay, err := strconv.Atoi(helpers.GetEnv("INFRABIN_MAX_DELAY", "120"))	1✔
78	if err != nil {	1✔
79	log.Fatalf("cannot convert env var INFRABIN_MAX_DELAY to integer: %v", err)	×
80	}	×
81	time.Sleep(time.Duration(helpers.Min(seconds, maxDelay)) * time.Second)	1✔
82		1✔
83	resp.Delay = strconv.Itoa(seconds)	1✔
84	data := helpers.MarshalResponseToString(resp)	1✔
85		1✔
86	w.WriteHeader(http.StatusOK)	1✔
87	_, err = io.WriteString(w, data)	1✔
88	if err != nil {	1✔
89	log.Fatal("error writing to ResponseWriter", err)	×
90	}	×
91	}
92	}
93
94	// HeadersHandler handles the headers endpoint
95	func HeadersHandler(w http.ResponseWriter, r *http.Request) {	1✔
96	var resp helpers.Response	1✔
97	w.Header().Set("Content-Type", "application/json")	1✔
98	resp.Headers = &r.Header	1✔
99		1✔
100	data := helpers.MarshalResponseToString(resp)	1✔
101	_, err := io.WriteString(w, data)	1✔
102	if err != nil {	1✔
103	log.Fatal("error writing to ResponseWriter: ", err)	×
104	}	×
105	}
106
107	// EnvHandler handles the env endpoint
108	func EnvHandler(w http.ResponseWriter, r *http.Request) {	2✔
109	var resp helpers.Response	2✔
110	vars := mux.Vars(r)	2✔
111	w.Header().Set("Content-Type", "application/json")	2✔
112	value := helpers.GetEnv(vars["env_var"], "")	2✔
113		2✔
114	if value == "" {	3✔
115	data := helpers.MarshalResponseToString(resp)	1✔
116	w.WriteHeader(http.StatusNotFound)	1✔
117	_, err := io.WriteString(w, data)	1✔
118	if err != nil {	1✔
119	log.Fatal("error writing to ResponseWriter", err)	×
120	}	×
121	} else {	1✔
122		1✔
123	resp.Env = map[string]string{	1✔
124	vars["env_var"]: value,	1✔
125	}	1✔
126	data := helpers.MarshalResponseToString(resp)	1✔
127		1✔
128	w.WriteHeader(http.StatusOK)	1✔
129	_, err := io.WriteString(w, data)	1✔
130	if err != nil {	1✔
131	log.Fatal("error writing to ResponseWriter", err)	×
132	}	×
133
134	}
135	}
136
137	func main() {	×
138	r := mux.NewRouter()	×
139	a := mux.NewRouter()	×
140	finish := make(chan bool)	×
141		×
142	r.HandleFunc("/", RootHandler)	×
143	r.HandleFunc("/delay/{seconds}", DelayHandler)	×
144	r.HandleFunc("/headers", HeadersHandler)	×
145	r.HandleFunc("/env/{env_var}", EnvHandler)	×
146		×
147	a.HandleFunc("/liveness", LivenessHandler)	×
148		×
149	serviceSrv := &http.Server{	×
150	Handler: r,	×
151	Addr: "0.0.0.0:8888",	×
152	// Good practice: enforce timeouts	×
153	WriteTimeout: 15 * time.Second,	×
154	ReadTimeout: 15 * time.Second,	×
155	}	×
156	adminSrv := &http.Server{	×
157	Handler: a,	×
158	Addr: "0.0.0.0:8899",	×
159	// Good practice: enforce timeouts	×
160	WriteTimeout: 15 * time.Second,	×
161	ReadTimeout: 15 * time.Second,	×
162	}	×
163		×
164	log.Print("starting go-infrabin")	×
165		×
166	go func() {	×
167	log.Print("Listening on service port 8888...")	×
168	log.Fatal(serviceSrv.ListenAndServe())	×
169	}()	×
170
171	go func() {	×
172	log.Print("Listening on admin port 8899...")	×
173	log.Fatal(adminSrv.ListenAndServe())	×
174	}()	×
175	<-finish	×
176	}

maruina / go-infrabin / 106462226

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