1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.aether.transport.http;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.io.InputStream;
24 import java.io.InterruptedIOException;
25 import java.io.OutputStream;
26 import java.io.UncheckedIOException;
27 import java.net.URI;
28 import java.net.URISyntaxException;
29 import java.nio.charset.Charset;
30 import java.nio.file.Files;
31 import java.nio.file.StandardCopyOption;
32 import java.util.Collections;
33 import java.util.Date;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.regex.Matcher;
37 import java.util.regex.Pattern;
38
39 import org.apache.http.Header;
40 import org.apache.http.HttpEntity;
41 import org.apache.http.HttpEntityEnclosingRequest;
42 import org.apache.http.HttpHeaders;
43 import org.apache.http.HttpHost;
44 import org.apache.http.HttpStatus;
45 import org.apache.http.auth.AuthSchemeProvider;
46 import org.apache.http.auth.AuthScope;
47 import org.apache.http.client.CredentialsProvider;
48 import org.apache.http.client.HttpResponseException;
49 import org.apache.http.client.config.AuthSchemes;
50 import org.apache.http.client.config.RequestConfig;
51 import org.apache.http.client.methods.CloseableHttpResponse;
52 import org.apache.http.client.methods.HttpGet;
53 import org.apache.http.client.methods.HttpHead;
54 import org.apache.http.client.methods.HttpOptions;
55 import org.apache.http.client.methods.HttpPut;
56 import org.apache.http.client.methods.HttpUriRequest;
57 import org.apache.http.client.utils.DateUtils;
58 import org.apache.http.client.utils.URIUtils;
59 import org.apache.http.config.Registry;
60 import org.apache.http.config.RegistryBuilder;
61 import org.apache.http.config.SocketConfig;
62 import org.apache.http.entity.AbstractHttpEntity;
63 import org.apache.http.entity.ByteArrayEntity;
64 import org.apache.http.impl.NoConnectionReuseStrategy;
65 import org.apache.http.impl.auth.BasicScheme;
66 import org.apache.http.impl.auth.BasicSchemeFactory;
67 import org.apache.http.impl.auth.DigestSchemeFactory;
68 import org.apache.http.impl.auth.KerberosSchemeFactory;
69 import org.apache.http.impl.auth.NTLMSchemeFactory;
70 import org.apache.http.impl.auth.SPNegoSchemeFactory;
71 import org.apache.http.impl.client.CloseableHttpClient;
72 import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
73 import org.apache.http.impl.client.HttpClientBuilder;
74 import org.apache.http.util.EntityUtils;
75 import org.eclipse.aether.ConfigurationProperties;
76 import org.eclipse.aether.RepositorySystemSession;
77 import org.eclipse.aether.repository.AuthenticationContext;
78 import org.eclipse.aether.repository.Proxy;
79 import org.eclipse.aether.repository.RemoteRepository;
80 import org.eclipse.aether.spi.connector.transport.AbstractTransporter;
81 import org.eclipse.aether.spi.connector.transport.GetTask;
82 import org.eclipse.aether.spi.connector.transport.PeekTask;
83 import org.eclipse.aether.spi.connector.transport.PutTask;
84 import org.eclipse.aether.spi.connector.transport.TransportTask;
85 import org.eclipse.aether.transfer.NoTransporterException;
86 import org.eclipse.aether.transfer.TransferCancelledException;
87 import org.eclipse.aether.util.ConfigUtils;
88 import org.eclipse.aether.util.FileUtils;
89 import org.slf4j.Logger;
90 import org.slf4j.LoggerFactory;
91
92 import static java.util.Objects.requireNonNull;
93
94
95
96
97 final class HttpTransporter extends AbstractTransporter {
98
99 static final String SUPPORT_WEBDAV = "aether.connector.http.supportWebDav";
100
101 static final String PREEMPTIVE_PUT_AUTH = "aether.connector.http.preemptivePutAuth";
102
103 static final String USE_SYSTEM_PROPERTIES = "aether.connector.http.useSystemProperties";
104
105 private static final Pattern CONTENT_RANGE_PATTERN =
106 Pattern.compile("\\s*bytes\\s+([0-9]+)\\s*-\\s*([0-9]+)\\s*/.*");
107
108 private static final Logger LOGGER = LoggerFactory.getLogger(HttpTransporter.class);
109
110 private final Map<String, ChecksumExtractor> checksumExtractors;
111
112 private final AuthenticationContext repoAuthContext;
113
114 private final AuthenticationContext proxyAuthContext;
115
116 private final URI baseUri;
117
118 private final HttpHost server;
119
120 private final HttpHost proxy;
121
122 private final CloseableHttpClient client;
123
124 private final Map<?, ?> headers;
125
126 private final LocalState state;
127
128 private final boolean preemptiveAuth;
129
130 private final boolean preemptivePutAuth;
131
132 private final boolean supportWebDav;
133
134 HttpTransporter(
135 Map<String, ChecksumExtractor> checksumExtractors,
136 RemoteRepository repository,
137 RepositorySystemSession session)
138 throws NoTransporterException {
139 if (!"http".equalsIgnoreCase(repository.getProtocol()) && !"https".equalsIgnoreCase(repository.getProtocol())) {
140 throw new NoTransporterException(repository);
141 }
142 this.checksumExtractors = requireNonNull(checksumExtractors, "checksum extractors must not be null");
143 try {
144 this.baseUri = new URI(repository.getUrl()).parseServerAuthority();
145 if (baseUri.isOpaque()) {
146 throw new URISyntaxException(repository.getUrl(), "URL must not be opaque");
147 }
148 this.server = URIUtils.extractHost(baseUri);
149 if (server == null) {
150 throw new URISyntaxException(repository.getUrl(), "URL lacks host name");
151 }
152 } catch (URISyntaxException e) {
153 throw new NoTransporterException(repository, e.getMessage(), e);
154 }
155 this.proxy = toHost(repository.getProxy());
156
157 this.repoAuthContext = AuthenticationContext.forRepository(session, repository);
158 this.proxyAuthContext = AuthenticationContext.forProxy(session, repository);
159
160 String httpsSecurityMode = ConfigUtils.getString(
161 session,
162 ConfigurationProperties.HTTPS_SECURITY_MODE_DEFAULT,
163 ConfigurationProperties.HTTPS_SECURITY_MODE + "." + repository.getId(),
164 ConfigurationProperties.HTTPS_SECURITY_MODE);
165 final int connectionMaxTtlSeconds = ConfigUtils.getInteger(
166 session,
167 ConfigurationProperties.DEFAULT_HTTP_CONNECTION_MAX_TTL,
168 ConfigurationProperties.HTTP_CONNECTION_MAX_TTL + "." + repository.getId(),
169 ConfigurationProperties.HTTP_CONNECTION_MAX_TTL);
170 final int maxConnectionsPerRoute = ConfigUtils.getInteger(
171 session,
172 ConfigurationProperties.DEFAULT_HTTP_MAX_CONNECTIONS_PER_ROUTE,
173 ConfigurationProperties.HTTP_MAX_CONNECTIONS_PER_ROUTE + "." + repository.getId(),
174 ConfigurationProperties.HTTP_MAX_CONNECTIONS_PER_ROUTE);
175 this.state = new LocalState(
176 session,
177 repository,
178 new ConnMgrConfig(
179 session, repoAuthContext, httpsSecurityMode, connectionMaxTtlSeconds, maxConnectionsPerRoute));
180
181 this.headers = ConfigUtils.getMap(
182 session,
183 Collections.emptyMap(),
184 ConfigurationProperties.HTTP_HEADERS + "." + repository.getId(),
185 ConfigurationProperties.HTTP_HEADERS);
186
187 this.preemptiveAuth = ConfigUtils.getBoolean(
188 session,
189 ConfigurationProperties.DEFAULT_HTTP_PREEMPTIVE_AUTH,
190 ConfigurationProperties.HTTP_PREEMPTIVE_AUTH + "." + repository.getId(),
191 ConfigurationProperties.HTTP_PREEMPTIVE_AUTH);
192 this.preemptivePutAuth =
193 ConfigUtils.getBoolean(
194 session, true, PREEMPTIVE_PUT_AUTH + "." + repository.getId(), PREEMPTIVE_PUT_AUTH);
195 this.supportWebDav =
196 ConfigUtils.getBoolean(session, false, SUPPORT_WEBDAV + "." + repository.getId(), SUPPORT_WEBDAV);
197 String credentialEncoding = ConfigUtils.getString(
198 session,
199 ConfigurationProperties.DEFAULT_HTTP_CREDENTIAL_ENCODING,
200 ConfigurationProperties.HTTP_CREDENTIAL_ENCODING + "." + repository.getId(),
201 ConfigurationProperties.HTTP_CREDENTIAL_ENCODING);
202 int connectTimeout = ConfigUtils.getInteger(
203 session,
204 ConfigurationProperties.DEFAULT_CONNECT_TIMEOUT,
205 ConfigurationProperties.CONNECT_TIMEOUT + "." + repository.getId(),
206 ConfigurationProperties.CONNECT_TIMEOUT);
207 int requestTimeout = ConfigUtils.getInteger(
208 session,
209 ConfigurationProperties.DEFAULT_REQUEST_TIMEOUT,
210 ConfigurationProperties.REQUEST_TIMEOUT + "." + repository.getId(),
211 ConfigurationProperties.REQUEST_TIMEOUT);
212 int retryCount = ConfigUtils.getInteger(
213 session,
214 ConfigurationProperties.DEFAULT_HTTP_RETRY_HANDLER_COUNT,
215 ConfigurationProperties.HTTP_RETRY_HANDLER_COUNT + "." + repository.getId(),
216 ConfigurationProperties.HTTP_RETRY_HANDLER_COUNT);
217 String userAgent = ConfigUtils.getString(
218 session, ConfigurationProperties.DEFAULT_USER_AGENT, ConfigurationProperties.USER_AGENT);
219
220 Charset credentialsCharset = Charset.forName(credentialEncoding);
221
222 Registry<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
223 .register(AuthSchemes.BASIC, new BasicSchemeFactory(credentialsCharset))
224 .register(AuthSchemes.DIGEST, new DigestSchemeFactory(credentialsCharset))
225 .register(AuthSchemes.NTLM, new NTLMSchemeFactory())
226 .register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory())
227 .register(AuthSchemes.KERBEROS, new KerberosSchemeFactory())
228 .build();
229
230 SocketConfig socketConfig =
231 SocketConfig.custom().setSoTimeout(requestTimeout).build();
232
233 RequestConfig requestConfig = RequestConfig.custom()
234 .setConnectTimeout(connectTimeout)
235 .setConnectionRequestTimeout(connectTimeout)
236 .setSocketTimeout(requestTimeout)
237 .build();
238
239 DefaultHttpRequestRetryHandler retryHandler = new DefaultHttpRequestRetryHandler(retryCount, false);
240
241 HttpClientBuilder builder = HttpClientBuilder.create()
242 .setUserAgent(userAgent)
243 .setDefaultSocketConfig(socketConfig)
244 .setDefaultRequestConfig(requestConfig)
245 .setRetryHandler(retryHandler)
246 .setDefaultAuthSchemeRegistry(authSchemeRegistry)
247 .setConnectionManager(state.getConnectionManager())
248 .setConnectionManagerShared(true)
249 .setDefaultCredentialsProvider(toCredentialsProvider(server, repoAuthContext, proxy, proxyAuthContext))
250 .setProxy(proxy);
251
252 final boolean useSystemProperties = ConfigUtils.getBoolean(
253 session, false, USE_SYSTEM_PROPERTIES + "." + repository.getId(), USE_SYSTEM_PROPERTIES);
254 if (useSystemProperties) {
255 LOGGER.warn(
256 "Transport used Apache HttpClient is instructed to use system properties: this may yield in unwanted side-effects!");
257 LOGGER.warn("Please use documented means to configure resolver transport.");
258 builder.useSystemProperties();
259 }
260
261 final boolean reuseConnections = ConfigUtils.getBoolean(
262 session,
263 ConfigurationProperties.DEFAULT_HTTP_REUSE_CONNECTIONS,
264 ConfigurationProperties.HTTP_REUSE_CONNECTIONS + "." + repository.getId(),
265 ConfigurationProperties.HTTP_REUSE_CONNECTIONS);
266 if (!reuseConnections) {
267 builder.setConnectionReuseStrategy(NoConnectionReuseStrategy.INSTANCE);
268 }
269
270 this.client = builder.build();
271 }
272
273 private static HttpHost toHost(Proxy proxy) {
274 HttpHost host = null;
275 if (proxy != null) {
276 host = new HttpHost(proxy.getHost(), proxy.getPort());
277 }
278 return host;
279 }
280
281 private static CredentialsProvider toCredentialsProvider(
282 HttpHost server, AuthenticationContext serverAuthCtx, HttpHost proxy, AuthenticationContext proxyAuthCtx) {
283 CredentialsProvider provider = toCredentialsProvider(server.getHostName(), AuthScope.ANY_PORT, serverAuthCtx);
284 if (proxy != null) {
285 CredentialsProvider p = toCredentialsProvider(proxy.getHostName(), proxy.getPort(), proxyAuthCtx);
286 provider = new DemuxCredentialsProvider(provider, p, proxy);
287 }
288 return provider;
289 }
290
291 private static CredentialsProvider toCredentialsProvider(String host, int port, AuthenticationContext ctx) {
292 DeferredCredentialsProvider provider = new DeferredCredentialsProvider();
293 if (ctx != null) {
294 AuthScope basicScope = new AuthScope(host, port);
295 provider.setCredentials(basicScope, new DeferredCredentialsProvider.BasicFactory(ctx));
296
297 AuthScope ntlmScope = new AuthScope(host, port, AuthScope.ANY_REALM, "ntlm");
298 provider.setCredentials(ntlmScope, new DeferredCredentialsProvider.NtlmFactory(ctx));
299 }
300 return provider;
301 }
302
303 LocalState getState() {
304 return state;
305 }
306
307 private URI resolve(TransportTask task) {
308 return UriUtils.resolve(baseUri, task.getLocation());
309 }
310
311 @Override
312 public int classify(Throwable error) {
313 if (error instanceof HttpResponseException
314 && ((HttpResponseException) error).getStatusCode() == HttpStatus.SC_NOT_FOUND) {
315 return ERROR_NOT_FOUND;
316 }
317 return ERROR_OTHER;
318 }
319
320 @Override
321 protected void implPeek(PeekTask task) throws Exception {
322 HttpHead request = commonHeaders(new HttpHead(resolve(task)));
323 execute(request, null);
324 }
325
326 @Override
327 protected void implGet(GetTask task) throws Exception {
328 boolean resume = true;
329 boolean applyChecksumExtractors = true;
330
331 EntityGetter getter = new EntityGetter(task);
332 HttpGet request = commonHeaders(new HttpGet(resolve(task)));
333 while (true) {
334 try {
335 if (resume) {
336 resume(request, task);
337 }
338 if (applyChecksumExtractors) {
339 for (ChecksumExtractor checksumExtractor : checksumExtractors.values()) {
340 checksumExtractor.prepareRequest(request);
341 }
342 }
343 execute(request, getter);
344 break;
345 } catch (HttpResponseException e) {
346 if (resume
347 && e.getStatusCode() == HttpStatus.SC_PRECONDITION_FAILED
348 && request.containsHeader(HttpHeaders.RANGE)) {
349 request = commonHeaders(new HttpGet(resolve(task)));
350 resume = false;
351 continue;
352 }
353 if (applyChecksumExtractors) {
354 boolean retryWithoutExtractors = false;
355 for (ChecksumExtractor checksumExtractor : checksumExtractors.values()) {
356 if (checksumExtractor.retryWithoutExtractor(e)) {
357 retryWithoutExtractors = true;
358 break;
359 }
360 }
361 if (retryWithoutExtractors) {
362 request = commonHeaders(new HttpGet(resolve(task)));
363 applyChecksumExtractors = false;
364 continue;
365 }
366 }
367 throw e;
368 }
369 }
370 }
371
372 @Override
373 protected void implPut(PutTask task) throws Exception {
374 PutTaskEntity entity = new PutTaskEntity(task);
375 HttpPut request = commonHeaders(entity(new HttpPut(resolve(task)), entity));
376 try {
377 execute(request, null);
378 } catch (HttpResponseException e) {
379 if (e.getStatusCode() == HttpStatus.SC_EXPECTATION_FAILED && request.containsHeader(HttpHeaders.EXPECT)) {
380 state.setExpectContinue(false);
381 request = commonHeaders(entity(new HttpPut(request.getURI()), entity));
382 execute(request, null);
383 return;
384 }
385 throw e;
386 }
387 }
388
389 private void execute(HttpUriRequest request, EntityGetter getter) throws Exception {
390 try {
391 SharingHttpContext context = new SharingHttpContext(state);
392 prepare(request, context);
393 try (CloseableHttpResponse response = client.execute(server, request, context)) {
394 try {
395 context.close();
396 handleStatus(response);
397 if (getter != null) {
398 getter.handle(response);
399 }
400 } finally {
401 EntityUtils.consumeQuietly(response.getEntity());
402 }
403 }
404 } catch (IOException e) {
405 if (e.getCause() instanceof TransferCancelledException) {
406 throw (Exception) e.getCause();
407 }
408 throw e;
409 }
410 }
411
412 private void prepare(HttpUriRequest request, SharingHttpContext context) {
413 final boolean put = HttpPut.METHOD_NAME.equalsIgnoreCase(request.getMethod());
414 if (preemptiveAuth || (preemptivePutAuth && put)) {
415 context.getAuthCache().put(server, new BasicScheme());
416 }
417 if (supportWebDav) {
418 if (state.getWebDav() == null && (put || isPayloadPresent(request))) {
419 HttpOptions req = commonHeaders(new HttpOptions(request.getURI()));
420 try (CloseableHttpResponse response = client.execute(server, req, context)) {
421 state.setWebDav(response.containsHeader(HttpHeaders.DAV));
422 EntityUtils.consumeQuietly(response.getEntity());
423 } catch (IOException e) {
424 LOGGER.debug("Failed to prepare HTTP context", e);
425 }
426 }
427 if (put && Boolean.TRUE.equals(state.getWebDav())) {
428 mkdirs(request.getURI(), context);
429 }
430 }
431 }
432
433 @SuppressWarnings("checkstyle:magicnumber")
434 private void mkdirs(URI uri, SharingHttpContext context) {
435 List<URI> dirs = UriUtils.getDirectories(baseUri, uri);
436 int index = 0;
437 for (; index < dirs.size(); index++) {
438 try (CloseableHttpResponse response =
439 client.execute(server, commonHeaders(new HttpMkCol(dirs.get(index))), context)) {
440 try {
441 int status = response.getStatusLine().getStatusCode();
442 if (status < 300 || status == HttpStatus.SC_METHOD_NOT_ALLOWED) {
443 break;
444 } else if (status == HttpStatus.SC_CONFLICT) {
445 continue;
446 }
447 handleStatus(response);
448 } finally {
449 EntityUtils.consumeQuietly(response.getEntity());
450 }
451 } catch (IOException e) {
452 LOGGER.debug("Failed to create parent directory {}", dirs.get(index), e);
453 return;
454 }
455 }
456 for (index--; index >= 0; index--) {
457 try (CloseableHttpResponse response =
458 client.execute(server, commonHeaders(new HttpMkCol(dirs.get(index))), context)) {
459 try {
460 handleStatus(response);
461 } finally {
462 EntityUtils.consumeQuietly(response.getEntity());
463 }
464 } catch (IOException e) {
465 LOGGER.debug("Failed to create parent directory {}", dirs.get(index), e);
466 return;
467 }
468 }
469 }
470
471 private <T extends HttpEntityEnclosingRequest> T entity(T request, HttpEntity entity) {
472 request.setEntity(entity);
473 return request;
474 }
475
476 private boolean isPayloadPresent(HttpUriRequest request) {
477 if (request instanceof HttpEntityEnclosingRequest) {
478 HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
479 return entity != null && entity.getContentLength() != 0;
480 }
481 return false;
482 }
483
484 private <T extends HttpUriRequest> T commonHeaders(T request) {
485 request.setHeader(HttpHeaders.CACHE_CONTROL, "no-cache, no-store");
486 request.setHeader(HttpHeaders.PRAGMA, "no-cache");
487
488 if (state.isExpectContinue() && isPayloadPresent(request)) {
489 request.setHeader(HttpHeaders.EXPECT, "100-continue");
490 }
491
492 for (Map.Entry<?, ?> entry : headers.entrySet()) {
493 if (!(entry.getKey() instanceof String)) {
494 continue;
495 }
496 if (entry.getValue() instanceof String) {
497 request.setHeader(entry.getKey().toString(), entry.getValue().toString());
498 } else {
499 request.removeHeaders(entry.getKey().toString());
500 }
501 }
502
503 if (!state.isExpectContinue()) {
504 request.removeHeaders(HttpHeaders.EXPECT);
505 }
506
507 return request;
508 }
509
510 @SuppressWarnings("checkstyle:magicnumber")
511 private <T extends HttpUriRequest> T resume(T request, GetTask task) {
512 long resumeOffset = task.getResumeOffset();
513 if (resumeOffset > 0L && task.getDataFile() != null) {
514 request.setHeader(HttpHeaders.RANGE, "bytes=" + resumeOffset + '-');
515 request.setHeader(
516 HttpHeaders.IF_UNMODIFIED_SINCE,
517 DateUtils.formatDate(new Date(task.getDataFile().lastModified() - 60L * 1000L)));
518 request.setHeader(HttpHeaders.ACCEPT_ENCODING, "identity");
519 }
520 return request;
521 }
522
523 @SuppressWarnings("checkstyle:magicnumber")
524 private void handleStatus(CloseableHttpResponse response) throws HttpResponseException {
525 int status = response.getStatusLine().getStatusCode();
526 if (status >= 300) {
527 throw new HttpResponseException(status, response.getStatusLine().getReasonPhrase() + " (" + status + ")");
528 }
529 }
530
531 @Override
532 protected void implClose() {
533 try {
534 client.close();
535 } catch (IOException e) {
536 throw new UncheckedIOException(e);
537 }
538 AuthenticationContext.close(repoAuthContext);
539 AuthenticationContext.close(proxyAuthContext);
540 state.close();
541 }
542
543 private class EntityGetter {
544
545 private final GetTask task;
546
547 EntityGetter(GetTask task) {
548 this.task = task;
549 }
550
551 public void handle(CloseableHttpResponse response) throws IOException, TransferCancelledException {
552 HttpEntity entity = response.getEntity();
553 if (entity == null) {
554 entity = new ByteArrayEntity(new byte[0]);
555 }
556
557 long offset = 0L, length = entity.getContentLength();
558 Header rangeHeader = response.getFirstHeader(HttpHeaders.CONTENT_RANGE);
559 String range = rangeHeader != null ? rangeHeader.getValue() : null;
560 if (range != null) {
561 Matcher m = CONTENT_RANGE_PATTERN.matcher(range);
562 if (!m.matches()) {
563 throw new IOException("Invalid Content-Range header for partial download: " + range);
564 }
565 offset = Long.parseLong(m.group(1));
566 length = Long.parseLong(m.group(2)) + 1L;
567 if (offset < 0L || offset >= length || (offset > 0L && offset != task.getResumeOffset())) {
568 throw new IOException("Invalid Content-Range header for partial download from offset "
569 + task.getResumeOffset() + ": " + range);
570 }
571 }
572
573 final boolean resume = offset > 0L;
574 final File dataFile = task.getDataFile();
575 if (dataFile == null) {
576 try (InputStream is = entity.getContent()) {
577 utilGet(task, is, true, length, resume);
578 extractChecksums(response);
579 }
580 } else {
581 try (FileUtils.CollocatedTempFile tempFile = FileUtils.newTempFile(dataFile.toPath())) {
582 task.setDataFile(tempFile.getPath().toFile(), resume);
583 if (resume && Files.isRegularFile(dataFile.toPath())) {
584 try (InputStream inputStream = Files.newInputStream(dataFile.toPath())) {
585 Files.copy(inputStream, tempFile.getPath(), StandardCopyOption.REPLACE_EXISTING);
586 }
587 }
588 try (InputStream is = entity.getContent()) {
589 utilGet(task, is, true, length, resume);
590 }
591 tempFile.move();
592 } finally {
593 task.setDataFile(dataFile);
594 }
595 }
596 extractChecksums(response);
597 }
598
599 private void extractChecksums(CloseableHttpResponse response) {
600 for (Map.Entry<String, ChecksumExtractor> extractorEntry : checksumExtractors.entrySet()) {
601 Map<String, String> checksums = extractorEntry.getValue().extractChecksums(response);
602 if (checksums != null) {
603 checksums.forEach(task::setChecksum);
604 return;
605 }
606 }
607 }
608 }
609
610 private class PutTaskEntity extends AbstractHttpEntity {
611
612 private final PutTask task;
613
614 PutTaskEntity(PutTask task) {
615 this.task = task;
616 }
617
618 @Override
619 public boolean isRepeatable() {
620 return true;
621 }
622
623 @Override
624 public boolean isStreaming() {
625 return false;
626 }
627
628 @Override
629 public long getContentLength() {
630 return task.getDataLength();
631 }
632
633 @Override
634 public InputStream getContent() throws IOException {
635 return task.newInputStream();
636 }
637
638 @Override
639 public void writeTo(OutputStream os) throws IOException {
640 try {
641 utilPut(task, os, false);
642 } catch (TransferCancelledException e) {
643 throw (IOException) new InterruptedIOException().initCause(e);
644 }
645 }
646 }
647 }