1 package main
2
3 import (
4 "context"
5 "fmt"
6 "os"
7 "strconv"
8
9 "github.com/datawire/dlib/dlog"
10 srv "github.com/emissary-ingress/emissary/v3/cmd/kat-server/services"
11 )
12
13 const (
14
15 Crt = "server.crt"
16
17 Key = "server.key"
18
19 Port int16 = 8080
20
21 SSLPort int16 = 8443
22 )
23
24 func main() {
25 ctx := context.Background()
26 listeners := make([]srv.Service, 0)
27 var s srv.Service
28
29 t := os.Getenv("KAT_BACKEND_TYPE")
30
31 if len(t) <= 0 {
32 t = "http"
33 }
34
35 dlog.Printf(ctx, "Running as type %s", t)
36
37 switch t {
38 case "grpc_echo":
39 s = &srv.GRPC{
40 Port: Port,
41 Backend: os.Getenv("BACKEND"),
42 SecurePort: SSLPort,
43 SecureBackend: os.Getenv("BACKEND"),
44 Cert: Crt,
45 Key: Key,
46 }
47
48 listeners = append(listeners, s)
49
50 case "grpc_auth":
51 protocolVersion := os.Getenv("GRPC_AUTH_PROTOCOL_VERSION")
52 if protocolVersion == "v3" {
53 s = &srv.GRPCAuthV3{
54 Port: Port,
55 Backend: os.Getenv("BACKEND"),
56 SecurePort: SSLPort,
57 SecureBackend: os.Getenv("BACKEND"),
58 Cert: Crt,
59 Key: Key,
60 ProtocolVersion: protocolVersion,
61 }
62 } else {
63 s = &srv.GRPCAuthV2{
64 Port: Port,
65 Backend: os.Getenv("BACKEND"),
66 SecurePort: SSLPort,
67 SecureBackend: os.Getenv("BACKEND"),
68 Cert: Crt,
69 Key: Key,
70 ProtocolVersion: protocolVersion,
71 }
72 }
73
74 listeners = append(listeners, s)
75
76 case "grpc_rls":
77 protocolVersion := os.Getenv("GRPC_RLS_PROTOCOL_VERSION")
78 if protocolVersion == "v3" {
79 s = &srv.GRPCRLSV3{
80 Port: Port,
81 Backend: os.Getenv("BACKEND"),
82 SecurePort: SSLPort,
83 SecureBackend: os.Getenv("BACKEND"),
84 Cert: Crt,
85 Key: Key,
86 ProtocolVersion: protocolVersion,
87 }
88
89 } else {
90 s = &srv.GRPCRLSV2{
91 Port: Port,
92 Backend: os.Getenv("BACKEND"),
93 SecurePort: SSLPort,
94 SecureBackend: os.Getenv("BACKEND"),
95 Cert: Crt,
96 Key: Key,
97 ProtocolVersion: protocolVersion,
98 }
99
100 }
101
102 listeners = append(listeners, s)
103 case "grpc_als":
104 s = &srv.GRPCALS{
105 HTTPListener: srv.HTTPListener{
106 CleartextPort: Port,
107 TLSPort: SSLPort,
108 TLSCert: Crt,
109 TLSKey: Key,
110 },
111 }
112 listeners = append(listeners, s)
113 case "grpc_agent":
114 s = &srv.GRPCAgent{
115 Port: Port,
116 }
117 listeners = append(listeners, s)
118 case "health_check_server":
119 port := Port
120 securePort := SSLPort
121
122 HealthyStatusCode, err := strconv.Atoi(os.Getenv("HEALTHY_STATUS_CODE"))
123 if err != nil {
124 HealthyStatusCode = 200
125 }
126 UnhealthyStatusCode, err := strconv.Atoi(os.Getenv("UNHEALTHY_STATUS_CODE"))
127 if err != nil {
128 UnhealthyStatusCode = 500
129 }
130
131 eName := fmt.Sprintf("BACKEND_%d", port)
132 clearBackend := os.Getenv(eName)
133
134 dlog.Printf(ctx, "clear: checking %s -- %s", eName, clearBackend)
135
136 if len(clearBackend) <= 0 {
137 if port == 8080 {
138
139 clearBackend = os.Getenv("BACKEND")
140
141 dlog.Printf(ctx, "clear: fallback to BACKEND -- %s", clearBackend)
142 }
143 }
144
145 if len(clearBackend) <= 0 {
146 dlog.Printf(ctx, "clear: bailing, no backend")
147 break
148 }
149
150 eName = fmt.Sprintf("BACKEND_%d", securePort)
151 secureBackend := os.Getenv(eName)
152
153 dlog.Printf(ctx, "secure: checking %s -- %s", eName, secureBackend)
154
155 if len(secureBackend) <= 0 {
156 if securePort == 8443 {
157
158 secureBackend = os.Getenv("BACKEND")
159
160 dlog.Printf(ctx, "secure: fallback to BACKEND -- %s", clearBackend)
161 }
162 }
163
164 if len(secureBackend) <= 0 {
165 dlog.Printf(ctx, "secure: bailing, no backend")
166 break
167 }
168
169 if clearBackend != secureBackend {
170 dlog.Printf(ctx, "BACKEND_%d and BACKEND_%d do not match", port, securePort)
171 } else {
172 dlog.Printf(ctx, "creating HTTP listener for %s on ports %d/%d", clearBackend, port, securePort)
173
174 s = &srv.HealthCheckServer{
175 Port: port,
176 Backend: clearBackend,
177 SecurePort: securePort,
178 SecureBackend: secureBackend,
179 Cert: Crt,
180 Key: Key,
181 HealthyStatusCode: HealthyStatusCode,
182 UnhealthyStatusCode: UnhealthyStatusCode,
183 }
184
185 listeners = append(listeners, s)
186 }
187
188 port++
189 securePort++
190 default:
191 port := Port
192 securePort := SSLPort
193
194 for {
195 eName := fmt.Sprintf("BACKEND_%d", port)
196 clearBackend := os.Getenv(eName)
197
198 dlog.Printf(ctx, "clear: checking %s -- %s", eName, clearBackend)
199
200 if len(clearBackend) <= 0 {
201 if port == 8080 {
202
203 clearBackend = os.Getenv("BACKEND")
204
205 dlog.Printf(ctx, "clear: fallback to BACKEND -- %s", clearBackend)
206 }
207 }
208
209 if len(clearBackend) <= 0 {
210 dlog.Printf(ctx, "clear: bailing, no backend")
211 break
212 }
213
214 eName = fmt.Sprintf("BACKEND_%d", securePort)
215 secureBackend := os.Getenv(eName)
216
217 dlog.Printf(ctx, "secure: checking %s -- %s", eName, secureBackend)
218
219 if len(secureBackend) <= 0 {
220 if securePort == 8443 {
221
222 secureBackend = os.Getenv("BACKEND")
223
224 dlog.Printf(ctx, "secure: fallback to BACKEND -- %s", clearBackend)
225 }
226 }
227
228 if len(secureBackend) <= 0 {
229 dlog.Printf(ctx, "secure: bailing, no backend")
230 break
231 }
232
233 if clearBackend != secureBackend {
234 dlog.Printf(ctx, "BACKEND_%d and BACKEND_%d do not match", port, securePort)
235 } else {
236 dlog.Printf(ctx, "creating HTTP listener for %s on ports %d/%d", clearBackend, port, securePort)
237
238 s = &srv.HTTP{
239 Port: port,
240 Backend: clearBackend,
241 SecurePort: securePort,
242 SecureBackend: secureBackend,
243 Cert: Crt,
244 Key: Key,
245 }
246
247 listeners = append(listeners, s)
248 }
249
250 port++
251 securePort++
252 }
253 }
254
255 if len(listeners) > 0 {
256 var waitFor <-chan bool
257 first := true
258
259 for _, s := range listeners {
260 c := s.Start(ctx)
261
262 if first {
263 waitFor = c
264 first = false
265 }
266 }
267
268 <-waitFor
269 } else {
270 dlog.Error(ctx, "no listeners, exiting")
271 os.Exit(1)
272 }
273 }
274
View as plain text