Timeout between request retries Apache HttpClient - httpclient

Question

Could somebody share how to configure modern HttpClient 4.5.3 to retry failed requests and wait for some time before each retry?
So far it looks like I got it correctly that .setRetryHandler(new DefaultHttpRequestRetryHandler(X, false)) will allow to retry requests X times.
But I cannot understand how to configure backoff: .setConnectionBackoffStrategy() / .setBackoffManager() according to JavaDocs regulate something else, not timeout between retries.

Answer 1

About the dynamic delay, I want to suggest this:
CloseableHttpClient client = HttpClientBuilder.create()
.setRetryHandler(new HttpRequestRetryHandler() {
#Override
public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
return executionCount <= maxRetries ;
}
})
.setServiceUnavailableRetryStrategy(new ServiceUnavailableRetryStrategy() {
int waitPeriod = 100;
#Override
public boolean retryRequest(HttpResponse response, int executionCount, HttpContext context) {
waitPeriod *= 2;
return executionCount <= maxRetries &&
response.getStatusLine().getStatusCode() >= 500; //important!
}
#Override
public long getRetryInterval() {
return waitPeriod;
}
})
.build();
Appendix:
Please note, that ServiceUnavailableRetryStrategy.retryRequest will NOT be called, if there was an IO error like timeout, port not open or connection closed. In such cases, only HttpRequestRetryHandler.retryRequest will be called, and the retry will happen either immediately or after a fixed delay (I could not finally clarify this). So oleg's answer is actually the right one. There is no way to do it with support of HttpClient 4.5.
(I would actually like to call this a design bug, as delayed retries after an IO error are vitally important in a modern microservice environment.)

Answer 2

BackoffManager / ConnectionBackoffStrategy combo can be used to dynamically increase or decrease max connection per route limits based on rate of I/O errors and 503 responses. They have no influence on request execution and cannot be used to control request re-execution
This is the best one can do with HC 4.x APIs
CloseableHttpClient client = HttpClientBuilder.create()
.setRetryHandler(new HttpRequestRetryHandler() {
#Override
public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
return executionCount <= maxRetries &&
exception instanceof SocketException;
}
})
.setServiceUnavailableRetryStrategy(new ServiceUnavailableRetryStrategy() {
#Override
public boolean retryRequest(HttpResponse response, int executionCount, HttpContext context) {
return executionCount <= maxRetries &&
response.getStatusLine().getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE;
}
#Override
public long getRetryInterval() {
return 100;
}
})
.build();
Please note there is presently no elegant way of enforcing a delay between request execution attempts in case of an I/O error or dynamically adjusting the retry interval based on request route.

Answer 3

You can use lambda
client.setRetryHandler((e, execCount, httpContext) -> {
if (execCount > tries) {
return false;
} else {
try {
Thread.sleep(recalMillis);
} catch (InterruptedException ex) {
//ignore
}
return true;
}
Notice that handler works only for IOExceptions types

Answer 4

This worked for us. This does both retries (3) and a delay (1000ms). We override two things, HttpResponseInterceptor.process() and HttpRequestRetryHandler.retryRequest(). The first will throw an exception for invalid (400+) HTTP codes which will come to the retryRequest implementation. NOTE: If all retries have been exhausted, you will come to the final Catch at the bottom of this snippet.
// Define an HttpClient with the following features:
// 1) Intercept HTTP response to detect any 400+ HTTP Codes (process() implementation), and if so,
// 2) Force a retry with a delay (HttpRequestRetryHandler.retryRequest() implementation)
final CloseableHttpClient httpClient = HttpClients.custom().addInterceptorLast(new HttpResponseInterceptor() {
#Override
public void process(HttpResponse response, HttpContext context) throws HttpException, IOException {
if (response.getStatusLine().getStatusCode() >= 400) {
// Throw an IOException to force a retry via HttpRequestRetryHandler.retryRequest()
throw new IOException("Invalid code returned: " + response.getStatusLine().getStatusCode());
}
}
})
.setRetryHandler(new HttpRequestRetryHandler() {
#Override
public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
if (executionCount > MAX_RETRIES) { // MAX_RETRIES = 3
return false;
} else {
try {
// Sleep before retrying
Thread.sleep(DELAY); // DELAY = 1000 MS
} catch (InterruptedException ex) {
// ... Log or silently swallow
}
return true;
}
}
})
.build();
final HttpGet getOp = new HttpGet("http://yoururl.com/api/123/");
try {
return httpClient.execute(getOp, new ResponseHandler<String>() {
#Override
public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
// ... Process response after preliminary HTTP code verification
}
});
} catch (IOException ioe) {
// NOTE: Comes here if all retries have failed, throw error back to caller
log.error("All retries have been exhausted");
throw ioe;
}