import java.io.IOException;
import java.io.InputStream;
import java.net.URI;

public class HttpClientResponse implements Closeable {

    private final String method;
    private final URI effectiveUri;
    private final CloseableHttpResponse httpResponse;
    private boolean closed;

    HttpClientResponse(String method, URI effectiveUri, CloseableHttpResponse httpResponse) {
        this.method = method;

        String uri = location.getUri().toString();
        LOGGER.debug("Constructing external resource: {}", location);

        HttpClientResponse response = http.performGet(uri, revalidate);
        return wrapResponse(location.getUri(), response);
    }

    /**
     * Same as #getResource except that it always gives access to the response body,

        }
    }

    private HttpClientResponse performRawHead(String source, boolean revalidate) {
        return performRequest(new HttpHead(source), revalidate);
    }

    public HttpClientResponse performHead(String source, boolean revalidate) {
        return processResponse(performRawHead(source, revalidate));
    }

    HttpClientResponse performRawGet(String source, boolean revalidate) {

    private final String method;
    private final URI source;
    private final HttpClientResponse response;
    private final ExternalResourceMetaData metaData;
    private boolean wasOpened;

    public HttpResponseResource(String method, URI source, HttpClientResponse response) {
        this.method = method;
        this.source = source;
        this.response = response;

    def "throws HttpRequestException if an IO error occurs during a request"() {
        def client = new HttpClientHelper(new DocumentationRegistry(), httpSettings) {
            @Override
            protected HttpClientResponse executeGetOrHead(HttpRequestBase method) {
                throw new IOException("ouch")
            }
        }

        when:
        client.performRequest(new HttpGet("http://gradle.org"), false)

import org.gradle.caching.BuildCacheService;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.resource.transport.http.HttpClientHelper;
import org.gradle.internal.resource.transport.http.HttpClientResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;

    @Issue("GRADLE-3574")
    def "should not generate any concurrent exception"() {
        def http = Mock(HttpClientHelper) {
            performGet(uri.toString(), _) >> Mock(HttpClientResponse)
        }
        def httpResourceAccessor = new HttpResourceAccessor(http)

        when:
        10.times {
            concurrent.start {
                100.times {

        when:
        new HttpResourceUploader(client).upload(resource, name)

        then:
        interaction {
            1 * client.performHttpRequest(_) >> new HttpClientResponse("PUT", uri, mockedHttpResponse.response)
            assertIsClosedCorrectly(mockedHttpResponse)
        }
        HttpErrorStatusCodeException exception = thrown()
        exception.message.contains('Could not PUT')

    def "should call close() on CloseableHttpResource when getMetaData is called"() {
        def response = mockHttpResponse()
        def http = Mock(HttpClientHelper) {
            performHead(uri.toString(), _) >> new HttpClientResponse("GET", uri, response)
        }

        when:
        new HttpResourceAccessor(http).getMetaData(name, false)

        then:
        1 * response.close()
    }

        final RepeatableInputStreamEntity entity = new RepeatableInputStreamEntity(resource, ContentType.APPLICATION_OCTET_STREAM);
        method.setEntity(entity);
        try (HttpClientResponse response = http.performHttpRequest(method)) {
            if (!response.wasSuccessful()) {
                URI effectiveUri = response.getEffectiveUri();