## http/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/InternalExecRuntime.java:94-127
94: 
95:     @Override
96:     public void acquireEndpoint(
97:             final String id, final HttpRoute route, final Object object, final HttpClientContext context) throws IOException {
98:         Args.notNull(route, "Route");
99:         if (endpointRef.get() == null) {
100:             final RequestConfig requestConfig = context.getRequestConfigOrDefault();
101:             final Timeout connectionRequestTimeout = requestConfig.getConnectionRequestTimeout();
102:             if (log.isDebugEnabled()) {
103:                 log.debug("{} acquiring endpoint ({})", id, connectionRequestTimeout);
104:             }
105:             final LeaseRequest connRequest = manager.lease(id, route, connectionRequestTimeout, object);
106:             state = object;
107:             if (cancellableDependency != null) {
108:                 cancellableDependency.setDependency(connRequest);
109:             }
110:             try {
111:                 final ConnectionEndpoint connectionEndpoint = connRequest.get(connectionRequestTimeout);
112:                 endpointRef.set(connectionEndpoint);
113:                 reusable = connectionEndpoint.isConnected();
114:                 if (cancellableDependency != null) {
115:                     cancellableDependency.setDependency(this);
116:                 }
117:                 if (log.isDebugEnabled()) {
118:                     log.debug("{} acquired endpoint {}", id, ConnPoolSupport.getId(connectionEndpoint));
119:                 }
120:             } catch (final TimeoutException ex) {
121:                 connRequest.cancel();
122:                 throw new ConnectionRequestTimeoutException(ex.getMessage());
123:             } catch (final InterruptedException interrupted) {
124:                 connRequest.cancel();
125:                 Thread.currentThread().interrupt();
126:                 throw new RequestFailedException("Request aborted", interrupted);
127:             } catch (final ExecutionException ex) {

## http/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/CloseableHttpClient.java:238-264
238:     public <T> T execute(
239:             final HttpHost target,
240:             final ClassicHttpRequest request,
241:             final HttpContext context,
242:             final HttpClientResponseHandler<? extends T> responseHandler) throws IOException {
243:         Args.notNull(responseHandler, "Response handler");
244: 
245:         try (final ClassicHttpResponse response = doExecute(target, request, context)) {
246:             try {
247:                 final T result = responseHandler.handleResponse(response);
248:                 final HttpEntity entity = response.getEntity();
249:                 EntityUtils.consume(entity);
250:                 return result;
251:             } catch (final HttpException t) {
252:                 // Try to salvage the underlying connection in case of a protocol exception
253:                 final HttpEntity entity = response.getEntity();
254:                 try {
255:                     EntityUtils.consume(entity);
256:                 } catch (final Exception t2) {
257:                     // Log this exception. The original exception is more
258:                     // important and will be thrown to the caller.
259:                     LOG.warn("Error consuming content after an exception.", t2);
260:                 }
261:                 throw new ClientProtocolException(t);
262:             }
263:         }
264:     }

## http/httpclient5/src/main/java/org/apache/hc/client5/http/config/RequestConfig.java:530-568
530:          */
531:         @Deprecated
532:         public Builder setConnectTimeout(final long connectTimeout, final TimeUnit timeUnit) {
533:             this.connectTimeout = Timeout.of(connectTimeout, timeUnit);
534:             return this;
535:         }
536: 
537:         /**
538:          * Determines the timeout until arrival of a response from the opposite
539:          * endpoint.
540:          * <p>
541:          * A timeout value of zero is interpreted as an infinite timeout.
542:          * </p>
543:          * <p>
544:          * Please note that response timeout may be unsupported by
545:          * HTTP transports with message multiplexing.
546:          * </p>
547:          * <p>
548:          * This parameter overrides the socket timeout setting applied at the connection
549:          * management or I/O layers for the duration of a message exchange.
550:          * </p>
551:          * <p>
552:          * Please note that response timeout is not a deadline. Its absolute value
553:          * can be exceeded, for example, in case of automatic request re-execution.
554:          * Please make sure the automatic request re-execution policy has been
555:          * configured appropriately.
556:          * </p>
557:          * <p>
558:          * Default: {@code null}
559:          * </p>
560:          *
561:          * @return this instance.
562:          * @since 5.0
563:          */
564:         public Builder setResponseTimeout(final Timeout responseTimeout) {
565:             this.responseTimeout = responseTimeout;
566:             return this;
567:         }
568: 

## http/httpclient5/src/main/java/org/apache/hc/client5/http/impl/DefaultHttpRequestRetryStrategy.java:155-205
155:      * <li>ConnectException</li>
156:      * <li>ConnectionClosedException</li>
157:      * <li>SSLException</li>
158:      * </ul>
159:      *
160:      * and retriable HTTP status codes:<br>
161:      * <ul>
162:      * <li>SC_TOO_MANY_REQUESTS (429)</li>
163:      * <li>SC_SERVICE_UNAVAILABLE (503)</li>
164:      * </ul>
165:      */
166:     public DefaultHttpRequestRetryStrategy() {
167:         this(1, TimeValue.ofSeconds(1L));
168:     }
169: 
170:     @Override
171:     public boolean retryRequest(
172:             final HttpRequest request,
173:             final IOException exception,
174:             final int execCount,
175:             final HttpContext context) {
176:         Args.notNull(request, "request");
177:         Args.notNull(exception, "exception");
178: 
179:         if (execCount > this.maxRetries) {
180:             // Do not retry if over max retries
181:             return false;
182:         }
183:         if (this.nonRetriableIOExceptionClasses.contains(exception.getClass())) {
184:             return false;
185:         }
186:         for (final Class<? extends IOException> rejectException : this.nonRetriableIOExceptionClasses) {
187:             if (rejectException.isInstance(exception)) {
188:                 return false;
189:             }
190:         }
191:         if (request instanceof CancellableDependency && ((CancellableDependency) request).isCancelled()) {
192:             return false;
193:         }
194: 
195:         // Retry if the request is considered idempotent
196:         return handleAsIdempotent(request);
197:     }
198: 
199:     @Override
200:     public boolean retryRequest(
201:             final HttpResponse response,
202:             final int execCount,
203:             final HttpContext context) {
204:         Args.notNull(response, "response");
205: 

## http/httpclient5/src/test/java/org/apache/hc/client5/http/impl/classic/TestCloseableHttpClient.java:108-166
108:     void testExecuteRequestHandleResponse() throws Exception {
109:         final HttpGet httpget = new HttpGet("https://somehost:444/stuff");
110: 
111:         Mockito.when(client.doExecute(
112:                 new HttpHost("https", "somehost", 444), httpget, null)).thenReturn(response);
113: 
114:         final HttpClientResponseHandler<HttpResponse> handler = Mockito.mock(HttpClientResponseHandler.class);
115: 
116:         client.execute(httpget, handler);
117: 
118:         Mockito.verify(client).doExecute(
119:                 Mockito.eq(new HttpHost("https", "somehost", 444)),
120:                 Mockito.same(httpget),
121:                 (HttpContext) Mockito.isNull());
122:         Mockito.verify(handler).handleResponse(response);
123:         Mockito.verify(content).close();
124:     }
125: 
126:     @Test
127:     void testExecuteRequestHandleResponseIOException() throws Exception {
128:         final HttpGet httpget = new HttpGet("https://somehost:444/stuff");
129: 
130:         Mockito.when(client.doExecute(
131:                 new HttpHost("https", "somehost", 444), httpget, null)).thenReturn(response);
132: 
133:         final HttpClientResponseHandler<HttpResponse> handler = Mockito.mock(HttpClientResponseHandler.class);
134: 
135:         Mockito.when(handler.handleResponse(response)).thenThrow(new IOException());
136: 
137:         Assertions.assertThrows(IOException.class, () ->
138:             client.execute(httpget, handler));
139:         Mockito.verify(client).doExecute(
140:                 Mockito.eq(new HttpHost("https", "somehost", 444)),
141:                 Mockito.same(httpget),
142:                 (HttpContext) Mockito.isNull());
143:         Mockito.verify(originResponse).close();
144:     }
145: 
146:     @Test
147:     void testExecuteRequestHandleResponseHttpException() throws Exception {
148:         final HttpGet httpget = new HttpGet("https://somehost:444/stuff");
149: 
150:         Mockito.when(client.doExecute(
151:                 new HttpHost("https", "somehost", 444), httpget, null)).thenReturn(response);
152: 
153:         final HttpClientResponseHandler<HttpResponse> handler = Mockito.mock(HttpClientResponseHandler.class);
154: 
155:         Mockito.when(handler.handleResponse(response)).thenThrow(new RuntimeException());
156: 
157:         Assertions.assertThrows(RuntimeException.class, () ->
158:                 client.execute(httpget, handler));
159:         Mockito.verify(client).doExecute(
160:                 Mockito.eq(new HttpHost("https", "somehost", 444)),
161:                 Mockito.same(httpget),
162:                 (HttpContext) Mockito.isNull());
163:         Mockito.verify(originResponse).close();
164:     }
165: 
166: }
