Golang: http proxy server to multiple endpoints based on some conditions - go

Question

I need to do some logic: proxy server that listen on port is receiving a request. It is always POST, and payload is always XML. I need to look inside it, and based on some conditions (XML tag values) i need to send original request to first or second backend.
I have something like this using standard http package, and it works - sometimes:
func main() {
[...]
server := &http.Server{
Handler: h,
ReadTimeout: time.Duration(*globalTimeout) * time.Millisecond,
}
log.Printf("Proxy engine ready and listen at %s, global timeout: %d ms", *listenAddress, *globalTimeout)
log.Fatalln(server.Serve(listener))
[...]
}
func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
var requestBody []byte
if r.Body != nil {
requestBody, _ = io.ReadAll(r.Body)
}
// rewind request body
r.Body = io.NopCloser(bytes.NewBuffer(requestBody))
relevantValues := getRelevantValues(requestBody)
if checkCondition(relevantValues) {
log.Println("Proxying request to endpoint 1")
r.URL = h.Target1
} else {
log.Println("Proxying request to endpoint 2")
r.URL = h.Target2
}
timeout := time.Duration(time.Duration(*globalTimeout).Milliseconds())
resp := handleRequest(r, timeout, r.URL.Scheme)
if resp != nil {
defer resp.Body.Close()
log.Printf("%s %s %v, %s", r.Method, r.URL.String(), r.Proto, resp.Status)
// Forward response headers
for k, v := range resp.Header {
w.Header()[k] = v
}
w.WriteHeader(resp.StatusCode)
// Forward response body
io.Copy(w, resp.Body)
} else {
log.Printf("Response is nil :(")
}
}
func handleRequest(request *http.Request, timeout time.Duration, scheme string) *http.Response {
var transport *http.Transport
if scheme == "https" {
transport = &http.Transport{
DialContext: (&net.Dialer{Timeout: timeout, KeepAlive: 10 * timeout}).DialContext,
DisableKeepAlives: *closeConnections,
TLSHandshakeTimeout: timeout,
ResponseHeaderTimeout: timeout,
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
} else {
transport = &http.Transport{
DialContext: (&net.Dialer{Timeout: timeout, KeepAlive: 10 * timeout}).DialContext,
DisableKeepAlives: *closeConnections,
TLSHandshakeTimeout: timeout,
ResponseHeaderTimeout: timeout,
}
}
response, err := transport.RoundTrip(request)
if err != nil {
log.Println("Request failed:", err)
}
return response
}
Sometimes it works, sometimes don't. Incoming request is always the same (from file on disk, posted with cURL):
2023/02/03 16:32:48 Proxy engine ready and listen at :8080, global timeout: 5000 ms
2023/02/03 16:32:53 Getting relevant values from request body
2023/02/03 16:32:53 Group: TS1
2023/02/03 16:32:53 Order number: 500000639557
2023/02/03 16:32:53 Check if order can be processed in endpoint 1
2023/02/03 16:32:53 Order can be processed in endpoint 1
2023/02/03 16:32:53 Proxying request to endpoint 1
2023/02/03 16:32:53 POST http://endpoint1:40002/service HTTP/1.1, 200 OK
2023/02/03 16:32:54 Getting relevant values from request body
2023/02/03 16:32:54 Group: TS1
2023/02/03 16:32:54 Order number: 500000639557
2023/02/03 16:32:54 Check if order can be processed in endpoint 1
2023/02/03 16:32:54 Order can be processed in endpoint 1
2023/02/03 16:32:54 Proxying request to endpoint 1
2023/02/03 16:32:54 POST http://endpoint1:40002/service HTTP/1.1, 200 OK
2023/02/03 16:32:55 Getting relevant values from request body
2023/02/03 16:32:55 Group: TS1
2023/02/03 16:32:55 Order number: 500000639557
2023/02/03 16:32:55 Check if order can be processed in endpoint 1
2023/02/03 16:32:55 Order can be processed in endpoint 1
2023/02/03 16:32:55 Proxying request to endpoint 1
2023/02/03 16:32:55 Request failed: EOF // exception from handleRequest function
2023/02/03 16:32:55 Response is nil :(
Does anyone know, what is going on and can help? Thanks!

Answer 1

I've modify handleRequest, now it is running as goroutine:
func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// [...]
ch := make(chan *http.Response)
var wg sync.WaitGroup
wg.Add(1)
timeout := time.Duration(time.Duration(*globalTimeout).Milliseconds())
go handleRequest(r, timeout, ch, &wg)
go func() {
wg.Wait()
close(ch)
}()
var resp *http.Response = <-ch
if resp != nil {
defer resp.Body.Close()
log.Printf("%s %s %v, %s", r.Method, r.URL.String(), r.Proto, resp.Status)
// [...]
}
}
func handleRequest(request *http.Request, timeout time.Duration, ch chan *http.Response, wg *sync.WaitGroup) {
defer (*wg).Done()
transport := &http.Transport{
DialContext: (&net.Dialer{Timeout: timeout, KeepAlive: 10 * timeout}).DialContext,
DisableKeepAlives: *closeConnections,
TLSHandshakeTimeout: timeout,
ResponseHeaderTimeout: timeout,
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
response, err := transport.RoundTrip(request)
if err != nil {
log.Println("Request failed:", err)
}
ch <- response
}
Now each request is served by separate thread, my parallel stress tests are 100% accurate.