100761632

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/7da6f0dfa57b525d79511505ee334c43dea67f17">7da6f0dfa<a href="https://github.com/maruina/go-infrabin/commit/7da6f0dfa57b525d79511505ee334c43dea67f17">">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/77cc2486bfd93dcad4a1b788242e3afc8a1d7613">77cc2486b</a>">77cc2486b</a><a href="https://github.com/maruina/go-infrabin/commit/7da6f0dfa57b525d79511505ee334c43dea67f17"> into 9d46f316f">9d46f316f</a>

Pull Request Pull Request #21: Add `env` endpoint

Run Details

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

92 of 151 relevant lines covered (60.93%)

0.87 hits per line

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

58.52

/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) {
        hostname, err := os.Hostname()
        if err != nil {
                log.Fatalf("cannot get hostname: %v", err)
        }
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)

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

maruina / go-infrabin / 100761632

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