JIRA:GRIF-315 upgrade to httpclient5

Author: alexole01

README.md

@@ -65,8 +65,8 @@ Since *GoodData Java SDK* version *2.32.0* API versioning is supported. The API
 ### Dependencies
 
 The *GoodData Java SDK* uses:
-* the [GoodData HTTP client](https://github.com/gooddata/gooddata-http-client) version 0.9.3 or later
-* the *Apache HTTP Client* version 4.5 or later (for white-labeled domains at least version 4.3.2 is required)
+* the [GoodData HTTP client](https://github.com/gooddata/gooddata-http-client) version 2.0.0 or later
+* the *Apache HTTP Client* version 5.2.x (for compatibility with older code, 4.5.x is also included for Sardine WebDAV library)
 * the *Spring Framework* version 6.x (compatible with Spring Boot 3.x)
 * the *Jackson JSON Processor* version 2.*
 * the *Slf4j API* version 2.0.*
@@ -106,6 +106,22 @@ Good SO thread about differences between various types in Java Date/Time API: ht
 Build the library with `mvn package`, see the
 [Testing](https://github.com/gooddata/gooddata-java/wiki/Testing) page for different testing methods.
 
+### Running Acceptance Tests
+
+To run acceptance tests against a real GoodData environment, use the following command:
+
+```bash
+# ⚠️ EXAMPLE ONLY - Replace with your actual credentials
+host=your-instance.gooddata.com \
+login=your.email@example.com \
+password=YOUR_PASSWORD_HERE \
+projectToken=YOUR_PROJECT_TOKEN \
+warehouseToken=YOUR_WAREHOUSE_TOKEN \
+mvn verify -P at
+```
+
+**Security Note:** Never commit real credentials to version control. Use environment variables or secure credential management systems in production.
+
 For releasing see [Releasing How-To](https://github.com/gooddata/gooddata-java/wiki/Releasing).
 
 ## Contribute

gooddata-java/src/main/java/com/gooddata/sdk/common/HttpClient4ComponentsClientHttpRequestFactory.java

@@ -6,11 +6,10 @@
 package com.gooddata.sdk.common;
 
 
-import org.apache.http.HttpEntityEnclosingRequest;
-import org.apache.http.HttpRequest;
-import org.apache.http.client.HttpClient;
-import org.apache.http.client.methods.*;
-import org.apache.http.entity.ByteArrayEntity;
+import org.apache.hc.core5.http.ClassicHttpRequest;
+import org.apache.hc.core5.http.io.entity.ByteArrayEntity;
+import org.apache.hc.core5.http.io.support.ClassicRequestBuilder;
+import org.apache.hc.client5.http.classic.HttpClient;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -29,19 +28,18 @@
 import java.util.Map;
 
 /**
- * Spring 6 compatible {@link ClientHttpRequestFactory} implementation that uses Apache HttpComponents HttpClient 4.x.
- * This is a custom implementation to bridge the gap between Spring 6 (which expects HttpClient 5.x) 
- * and our requirement to use HttpClient 4.x for compatibility.
+ * Spring 6 compatible {@link ClientHttpRequestFactory} implementation that uses Apache HttpComponents HttpClient 5.x.
+ * This is a custom implementation to bridge the gap between Spring 6 and HttpClient 5.x.
  */
 public class HttpClient4ComponentsClientHttpRequestFactory implements ClientHttpRequestFactory {
 
     private static final Logger logger = LoggerFactory.getLogger(HttpClient4ComponentsClientHttpRequestFactory.class);
     private final HttpClient httpClient;
 
     /**
-     * Create a factory with the given HttpClient 4.x instance.
+     * Create a factory with the given HttpClient 5.x instance.
      * 
-     * @param httpClient the HttpClient 4.x instance to use
+     * @param httpClient the HttpClient 5.x instance to use
      */
     public HttpClient4ComponentsClientHttpRequestFactory(HttpClient httpClient) {
         Assert.notNull(httpClient, "HttpClient must not be null");
@@ -50,50 +48,50 @@ public HttpClient4ComponentsClientHttpRequestFactory(HttpClient httpClient) {
 
     @Override
     public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
-        HttpUriRequest httpRequest = createHttpUriRequest(httpMethod, uri);
+        ClassicHttpRequest httpRequest = createHttpUriRequest(httpMethod, uri);
         return new HttpClient4ComponentsClientHttpRequest(httpClient, httpRequest);
     }
 
     /**
-     * Create an Apache HttpComponents HttpUriRequest object for the given HTTP method and URI.
+     * Create an Apache HttpComponents ClassicHttpRequest object for the given HTTP method and URI.
      * 
      * @param httpMethod the HTTP method
      * @param uri the URI
-     * @return the HttpUriRequest
+     * @return the ClassicHttpRequest
      */
-    private HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
+    private ClassicHttpRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {
         if (HttpMethod.GET.equals(httpMethod)) {
-            return new HttpGet(uri);
+            return ClassicRequestBuilder.get(uri).build();
         } else if (HttpMethod.HEAD.equals(httpMethod)) {
-            return new HttpHead(uri);
+            return ClassicRequestBuilder.head(uri).build();
         } else if (HttpMethod.POST.equals(httpMethod)) {
-            return new HttpPost(uri);
+            return ClassicRequestBuilder.post(uri).build();
         } else if (HttpMethod.PUT.equals(httpMethod)) {
-            return new HttpPut(uri);
+            return ClassicRequestBuilder.put(uri).build();
         } else if (HttpMethod.PATCH.equals(httpMethod)) {
-            return new HttpPatch(uri);
+            return ClassicRequestBuilder.patch(uri).build();
         } else if (HttpMethod.DELETE.equals(httpMethod)) {
-            return new HttpDelete(uri);
+            return ClassicRequestBuilder.delete(uri).build();
         } else if (HttpMethod.OPTIONS.equals(httpMethod)) {
-            return new HttpOptions(uri);
+            return ClassicRequestBuilder.options(uri).build();
         } else if (HttpMethod.TRACE.equals(httpMethod)) {
-            return new HttpTrace(uri);
+            return ClassicRequestBuilder.trace(uri).build();
         } else {
             throw new IllegalArgumentException("Invalid HTTP method: " + httpMethod);
         }
     }
 
     /**
-     * {@link ClientHttpRequest} implementation based on Apache HttpComponents HttpClient 4.x.
+     * {@link ClientHttpRequest} implementation based on Apache HttpComponents HttpClient 5.x.
      */
     private static class HttpClient4ComponentsClientHttpRequest implements ClientHttpRequest {
 
         private final HttpClient httpClient;
-        private final HttpUriRequest httpRequest;
+        private final ClassicHttpRequest httpRequest;
         private final HttpHeaders headers;
         private ByteArrayOutputStream bufferedOutput = new ByteArrayOutputStream(1024);
 
-        public HttpClient4ComponentsClientHttpRequest(HttpClient httpClient, HttpUriRequest httpRequest) {
+        public HttpClient4ComponentsClientHttpRequest(HttpClient httpClient, ClassicHttpRequest httpRequest) {
             this.httpClient = httpClient;
             this.httpRequest = httpRequest;
             this.headers = new HttpHeaders();
@@ -111,7 +109,11 @@ public String getMethodValue() {
 
         @Override
         public URI getURI() {
-            return httpRequest.getURI();
+            try {
+                return httpRequest.getUri();
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to get URI", e);
+            }
         }
 
         @Override
@@ -129,84 +131,35 @@ public ClientHttpResponse execute() throws IOException {
             // Create entity first (matching reference implementation exactly)
             byte[] bytes = bufferedOutput.toByteArray();
             if (bytes.length > 0) {
-                if (httpRequest instanceof HttpEntityEnclosingRequest) {
-                    HttpEntityEnclosingRequest entityRequest = (HttpEntityEnclosingRequest) httpRequest;
-                    
-                    // Ensure proper UTF-8 encoding before creating entity
-                    // This is crucial for @JsonTypeInfo annotated classes like Execution
-                    ByteArrayEntity requestEntity = new ByteArrayEntity(bytes);
-                    
-
-                    if (logger.isDebugEnabled()) {
-                        // Check if Content-Type is already set in headers
-                        boolean hasContentType = false;
-                        for (org.apache.http.Header header : httpRequest.getAllHeaders()) {
-                            if ("Content-Type".equalsIgnoreCase(header.getName())) {
-                                hasContentType = true;
-                                // String contentType = header.getValue();
-                                // logger.debug("Content-Type from headers: {}", contentType);
-                                break;
-                            }
-                        }
-                        
-                        if (!hasContentType) {
-                            // logger.debug("Default Content-Type set: application/json; charset=UTF-8");
-                        }
-                    }
-                    
-                    entityRequest.setEntity(requestEntity);
-                    
-                }
+                // HttpClient 5.x - set entity directly on the request
+                ByteArrayEntity requestEntity = new ByteArrayEntity(bytes, null);
+                httpRequest.setEntity(requestEntity);
             }
 
             // Set headers exactly like reference implementation
-            // (no additional headers parameter in our case, but same logic)
             addHeaders(httpRequest);
 
-            // Handle both GoodDataHttpClient and standard HttpClient
-            org.apache.http.HttpResponse httpResponse;
-            if (httpClient.getClass().getName().contains("GoodDataHttpClient")) {
-                // Use reflection to call the execute method on GoodDataHttpClient
-                try {
-                    // Try the single parameter execute method first
-                    java.lang.reflect.Method executeMethod = httpClient.getClass().getMethod("execute", 
-                        org.apache.http.client.methods.HttpUriRequest.class);
-                    httpResponse = (org.apache.http.HttpResponse) executeMethod.invoke(httpClient, httpRequest);
-                } catch (NoSuchMethodException e) {
-                    // If that doesn't work, try the two parameter version with HttpContext
-                    try {
-                        java.lang.reflect.Method executeMethod = httpClient.getClass().getMethod("execute", 
-                            org.apache.http.client.methods.HttpUriRequest.class, org.apache.http.protocol.HttpContext.class);
-                        httpResponse = (org.apache.http.HttpResponse) executeMethod.invoke(httpClient, httpRequest, null);
-                    } catch (Exception e2) {
-                        throw new IOException("Failed to execute request with GoodDataHttpClient", e2);
-                    }
-                } catch (Exception e) {
-                    throw new IOException("Failed to execute request with GoodDataHttpClient", e);
-                }
-            } else {
-                httpResponse = httpClient.execute(httpRequest);
-            }
-            return new HttpClient4ComponentsClientHttpResponse(httpResponse);
+            // Execute the request using HttpClient 5.x API
+            // The execute method with ResponseHandler automatically handles the response
+            return httpClient.execute(httpRequest, response -> {
+                // We need to consume and store the response since ResponseHandler closes it
+                return new HttpClient4ComponentsClientHttpResponse(response);
+            });
         }
 
         /**
          * Add the headers from the HttpHeaders to the HttpRequest.
-         * Excludes Content-Length headers to avoid conflicts with HttpClient 4.x internal management.
+         * Excludes Content-Length headers to avoid conflicts with HttpClient 5.x internal management.
          * Uses setHeader instead of addHeader to match the reference implementation.
-         * Follows HttpClient4ClientHttpRequest.executeInternal implementation pattern.
          */
-        private void addHeaders(HttpRequest httpRequest) {
+        private void addHeaders(ClassicHttpRequest httpRequest) {
             // CRITICAL for GoodData API: set headers in fixed order
             // for stable checksum. Order: Accept, X-GDC-Version, Content-Type, others
 
             // First clear potentially problematic headers
-            if (httpRequest instanceof HttpUriRequest) {
-                HttpUriRequest uriRequest = (HttpUriRequest) httpRequest;
-                uriRequest.removeHeaders("Accept");
-                uriRequest.removeHeaders("X-GDC-Version");
-                uriRequest.removeHeaders("Content-Type");
-            }
+            httpRequest.removeHeaders("Accept");
+            httpRequest.removeHeaders("X-GDC-Version");
+            httpRequest.removeHeaders("Content-Type");
 
             // 1. Accept header (first for checksum stability)
             if (headers.containsKey("Accept")) {
@@ -243,8 +196,9 @@ private void addHeaders(HttpRequest httpRequest) {
                     //     logger.debug("Using Spring Content-Type: {}", finalContentType);
                     // }
                 }
-            } else if (httpRequest instanceof HttpEntityEnclosingRequest) {
+            } else {
                 // Set default Content-Type for JSON requests with body
+                // In HttpClient 5.x, all requests can have entities, no need for instanceof check
                 finalContentType = "application/json; charset=UTF-8";
                 // if (logger.isDebugEnabled()) {
                 //     logger.debug("Default Content-Type for JSON requests: {}", finalContentType);

gooddata-java/src/main/java/com/gooddata/sdk/common/HttpClient4ComponentsClientHttpResponse.java

@@ -5,8 +5,9 @@
  */
 package com.gooddata.sdk.common;
 
-import org.apache.http.Header;
-import org.apache.http.HttpEntity;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.HttpEntity;
+import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.HttpStatusCode;
@@ -17,39 +18,39 @@
 import java.io.InputStream;
 
 /**
- * Spring 6 compatible {@link ClientHttpResponse} implementation that wraps Apache HttpComponents HttpClient 4.x response.
- * This bridges HttpClient 4.x responses with Spring 6's ClientHttpResponse interface.
+ * Spring 6 compatible {@link ClientHttpResponse} implementation that wraps Apache HttpComponents HttpClient 5.x response.
+ * This bridges HttpClient 5.x responses with Spring 6's ClientHttpResponse interface.
  * Package-private as it's only used internally within the common package.
  */
 class HttpClient4ComponentsClientHttpResponse implements ClientHttpResponse {
 
-    private final org.apache.http.HttpResponse httpResponse;
+    private final ClassicHttpResponse httpResponse;
     private HttpHeaders headers;
 
-    public HttpClient4ComponentsClientHttpResponse(org.apache.http.HttpResponse httpResponse) {
+    public HttpClient4ComponentsClientHttpResponse(ClassicHttpResponse httpResponse) {
         this.httpResponse = httpResponse;
     }
 
     @Override
     public HttpStatusCode getStatusCode() throws IOException {
-        return HttpStatusCode.valueOf(httpResponse.getStatusLine().getStatusCode());
+        return HttpStatusCode.valueOf(httpResponse.getCode());
     }
 
     @Override
     public int getRawStatusCode() throws IOException {
-        return httpResponse.getStatusLine().getStatusCode();
+        return httpResponse.getCode();
     }
 
     @Override
     public String getStatusText() throws IOException {
-        return httpResponse.getStatusLine().getReasonPhrase();
+        return httpResponse.getReasonPhrase();
     }
 
     @Override
     public HttpHeaders getHeaders() {
         if (headers == null) {
             headers = new HttpHeaders();
-            for (Header header : httpResponse.getAllHeaders()) {
+            for (Header header : httpResponse.getHeaders()) {
                 headers.add(header.getName(), header.getValue());
             }
         }
@@ -64,13 +65,9 @@ public InputStream getBody() throws IOException {
 
     @Override
     public void close() {
-        // HttpClient 4.x doesn't require explicit connection closing in most cases
-        // The connection is managed by the connection manager
+        // HttpClient 5.x - close the response
         try {
-            HttpEntity entity = httpResponse.getEntity();
-            if (entity != null && entity.getContent() != null) {
-                entity.getContent().close();
-            }
+            httpResponse.close();
         } catch (IOException e) {
             // Ignore close exceptions
         }

gooddata-java/src/main/java/com/gooddata/sdk/service/GoodDataEndpoint.java

@@ -5,7 +5,7 @@
  */
 package com.gooddata.sdk.service;
 
-import org.apache.http.HttpHost;
+import org.apache.hc.core5.http.HttpHost;
 
 import static com.gooddata.sdk.common.util.Validate.notEmpty;
 
@@ -62,7 +62,7 @@ public GoodDataEndpoint() {
      * @return the host URI, as a string.
      */
     public String toUri() {
-        return new HttpHost(hostname, port, protocol).toURI();
+        return new HttpHost(protocol, hostname, port).toURI();
     }
 
     /**

gooddata-java/src/main/java/com/gooddata/sdk/service/GoodDataSettings.java

@@ -9,8 +9,7 @@
 import com.gooddata.sdk.service.retry.RetrySettings;
 import com.gooddata.sdk.common.util.GoodDataToStringBuilder;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.http.impl.client.HttpClientBuilder;
-import org.apache.http.util.VersionInfo;
+import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
 import org.springframework.http.MediaType;
 import org.springframework.util.StreamUtils;
 
@@ -22,7 +21,6 @@
 import java.util.concurrent.TimeUnit;
 
 import static com.gooddata.sdk.common.util.Validate.notNull;
-import static org.apache.http.util.VersionInfo.loadVersionInfo;
 import static org.springframework.util.Assert.isTrue;
 
 /**
@@ -299,8 +297,10 @@ private String getDefaultUserAgent() {
         final String clientVersion = pkg != null && pkg.getImplementationVersion() != null
                 ? pkg.getImplementationVersion() : UNKNOWN_VERSION;
 
-        final VersionInfo vi = loadVersionInfo("org.apache.http.client", HttpClientBuilder.class.getClassLoader());
-        final String apacheVersion = vi != null ? vi.getRelease() : UNKNOWN_VERSION;
+        // Get HttpClient 5.x version from package
+        final Package httpClientPkg = HttpClientBuilder.class.getPackage();
+        final String apacheVersion = httpClientPkg != null && httpClientPkg.getImplementationVersion() != null
+                ? httpClientPkg.getImplementationVersion() : UNKNOWN_VERSION;
 
         return String.format("%s/%s (%s; %s) %s/%s", "GoodData-Java-SDK", clientVersion,
                 System.getProperty("os.name"), System.getProperty("java.specification.version"),