Reusing Keep-Alive Connection in case of Timeout in Golang - go

Question

/* Keep Alive Client*/
HttpClient{
Client: &http.Client{
Transport: &http.Transport{
Dial: (&net.Dialer{
Timeout: dialTimeout,
KeepAlive: dialTimeout * 60,
}).Dial,
DisableKeepAlives: false,
MaxIdleConnsPerHost: idleConnectionsPerHost,
},
},
Timeout: 5 * time.Second,
}
/* Execute Request */
timeoutContext, cancelFunction := context.WithTimeout(context.Background(), self.Timeout)
defer cancelFunction()
if response, err = self.Client.Do(request.WithContext(timeoutContext)); err == nil {
defer response.Body.Close()
/* Check If Request was Successful */
statusCode = response.StatusCode
if response.StatusCode == http.StatusOK {
/* Read Body & Decode if Response came & unmarshal entity is supplied */
if responseBytes, err = ioutil.ReadAll(response.Body); err == nil && unmarshalledResponse != nil {
//Process Response
}
} else {
err = errors.New(fmt.Sprintf("Non 200 Response. Status Code: %v", response.StatusCode))
}
}
In Golang whenever a request times out in a Keep-Alive connection that connection is lost and is Reset. For the above code incase of timeout Seeing Packets in Wireshark reveals that RST is sent by the client hence connection is no longer reused.
Event tried using Timeout of Httpclient rather than ContextWithTimeout but having similar findings where connection gets reset.
Anyway we can retain established keep-alive connection even in case of a Timeout of request.

Answer 1

The net/http client closes the connection on timeout because the connection cannot be reused.
Consider what would happen if the connection is reused. If the client receives none of the response or a partial response from the server before timeout, then the next request will read some amount of the previous response.
To keep the connection alive on timeout, implement the timeout in application code. Continue to use a longer timeout in the net/http client to handle cases where the connection is truly stuck or dead.
result := make(chan []byte)
go func() {
defer close(result)
resp, err := client.Do(request)
if err != nil {
// return
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusOK {
p, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
result <- resp
}
}()
select {
case p, ok <- result:
if ok {
// p is the response body
}
case time.After(timeout):
// do nothing
}