private void internalExecute(
            final State state,
            final HttpRequest request,
            final AsyncEntityProducer entityProducer,
            final AsyncExecChain.Scope scope,
            final AsyncExecChain chain,
            final AsyncExecCallback asyncExecCallback) throws HttpException, IOException {

        final String exchangeId = scope.exchangeId;

        chain.proceed(BasicRequestBuilder.copy(request).build(), entityProducer, scope, new AsyncExecCallback() {

            @Override
            public AsyncDataConsumer handleResponse(
                    final HttpResponse response,
                    final EntityDetails entityDetails) throws HttpException, IOException {
                final HttpClientContext clientContext = scope.clientContext;
                if (entityProducer != null && !entityProducer.isRepeatable()) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("{} cannot retry non-repeatable request", exchangeId);
                    }
                    return asyncExecCallback.handleResponse(response, entityDetails);
                }
                state.retrying = retryStrategy.retryRequest(response, scope.execCount.get(), clientContext);
                if (state.retrying) {
                    state.delay = retryStrategy.getRetryInterval(response, scope.execCount.get(), clientContext);
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("{} retrying request in {}", exchangeId, state.delay);
                    }
                    return new DiscardingEntityConsumer<>();
                }
                return asyncExecCallback.handleResponse(response, entityDetails);
            }

            @Override
            public void handleInformationResponse(final HttpResponse response) throws HttpException, IOException {
                asyncExecCallback.handleInformationResponse(response);
            }

            @Override
            public void completed() {
                if (state.retrying) {
                    scope.execCount.incrementAndGet();
                    if (entityProducer != null) {
                       entityProducer.releaseResources();
                    }
                    scope.scheduler.scheduleExecution(
                            request,
                            entityProducer,
                            scope,
                            (r, e, s, c) -> execute(r, e, s, chain, c),
                            asyncExecCallback,
                            state.delay);
                } else {
                    asyncExecCallback.completed();
                }
            }

            @Override
            public void failed(final Exception cause) {
                if (cause instanceof IOException) {
                    final HttpRoute route = scope.route;
                    final HttpClientContext clientContext = scope.clientContext;
                    if (entityProducer != null && !entityProducer.isRepeatable()) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("{} cannot retry non-repeatable request", exchangeId);
                        }
                    } else if (retryStrategy.retryRequest(request, (IOException) cause, scope.execCount.get(), clientContext)) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("{} {}", exchangeId, cause.getMessage(), cause);
                        }
                        if (LOG.isInfoEnabled()) {
                            LOG.info("Recoverable I/O exception ({}) caught when processing request to {}",
                                    cause.getClass().getName(), route);
                        }
                        scope.execRuntime.discardEndpoint();
                        if (entityProducer != null) {
                            entityProducer.releaseResources();
                        }
                        state.retrying = true;
                        final int execCount = scope.execCount.incrementAndGet();
                        state.delay = retryStrategy.getRetryInterval(request, (IOException) cause, execCount - 1, clientContext);
                        scope.scheduler.scheduleExecution(
                                request,
                                entityProducer,
                                scope,
                                (r, e, s, c) -> execute(r, e, s, chain, c),
                                asyncExecCallback,
                                state.delay);
                        return;
                    }
                }
                asyncExecCallback.failed(cause);
            }

        });

    }
Request executor in the asynchronous request execution chain that is
responsible for making a decision whether a request that failed due to
an I/O exception or received a specific response from the target server should
be re-executed.
<p>
Further responsibilities such as communication with the opposite
endpoint is delegated to the next executor in the request execution
chain.
</p>
<p>
If this handler is active, pay particular attention to the placement
of other handlers within the handler chain relative to the retry handler.
Use {@link ChainElement#RETRY} as name when referring to this handler.
</p>
<p>
If a custom handler is placed <b>before</b> the retry handler, the handler will
see the initial request and the final outcome after the last retry. Elapsed time
will account for any delays imposed by the retry handler.
</p>

<p>
A custom handler which is placed <b>after</b> the retry handler will be invoked for
each individual retry. Elapsed time will measure each individual http request,
without the delay imposed by the retry handler.
</p>

@since 5.0
httpclient5/src/main/java/org/apache/hc/client5/http/impl/async/AsyncHttpRequestRetryExec.java