JIRA:GRIF-315 upgrade to httpclient5 full

Author: alexole01

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

@@ -7,6 +7,7 @@
 
 
 import org.apache.hc.core5.http.ClassicHttpRequest;
+import org.apache.hc.core5.http.ClassicHttpResponse;
 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;
@@ -139,12 +140,27 @@ public ClientHttpResponse execute() throws IOException {
             // Set headers exactly like reference implementation
             addHeaders(httpRequest);
 
-            // 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
+            // Extract HttpHost from the request URI for GoodDataHttpClient
+            // GoodDataHttpClient requires the target host to be explicitly provided
+            // to properly handle authentication and token management
+            try {
+                URI requestUri = httpRequest.getUri();
+                org.apache.hc.core5.http.HttpHost target = new org.apache.hc.core5.http.HttpHost(
+                    requestUri.getScheme(),
+                    requestUri.getHost(),
+                    requestUri.getPort()
+                );
+                
+                // CRITICAL: Call execute() WITHOUT ResponseHandler to ensure GoodDataHttpClient's
+                // authentication logic is invoked. The version with ResponseHandler bypasses auth!
+                // See: gooddata-http-client:2.0.0 GoodDataHttpClient.execute() implementation
+                ClassicHttpResponse response = httpClient.execute(target, httpRequest);
+                
+                // We need to consume and store the response immediately since the connection may be closed
                 return new HttpClient4ComponentsClientHttpResponse(response);
-            });
+            } catch (java.net.URISyntaxException e) {
+                throw new IOException("Failed to extract target host from request URI", e);
+            }
         }
 
         /**

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

@@ -14,62 +14,90 @@
 import org.springframework.http.client.ClientHttpResponse;
 
 import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
 /**
  * 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.
+ * 
+ * <p>IMPORTANT: This class buffers the entire response body in memory to avoid issues with
+ * HttpClient 5.x's ResponseHandler automatically closing the response stream. This is necessary
+ * because Spring 6's IntrospectingClientHttpResponse needs to read the stream after the
+ * ResponseHandler has returned.
+ * 
  * Package-private as it's only used internally within the common package.
  */
 class HttpClient4ComponentsClientHttpResponse implements ClientHttpResponse {
 
-    private final ClassicHttpResponse httpResponse;
-    private HttpHeaders headers;
+    private final int statusCode;
+    private final String reasonPhrase;
+    private final HttpHeaders headers;
+    private final byte[] bodyBytes;
 
-    public HttpClient4ComponentsClientHttpResponse(ClassicHttpResponse httpResponse) {
-        this.httpResponse = httpResponse;
+    /**
+     * Creates a response wrapper that immediately buffers the response body.
+     * This must be called within the ResponseHandler before the response is closed.
+     * 
+     * @param httpResponse the HttpClient 5.x response to wrap
+     * @throws IOException if reading the response body fails
+     */
+    public HttpClient4ComponentsClientHttpResponse(ClassicHttpResponse httpResponse) throws IOException {
+        // Capture response metadata immediately
+        this.statusCode = httpResponse.getCode();
+        this.reasonPhrase = httpResponse.getReasonPhrase();
+        
+        // Copy headers
+        this.headers = new HttpHeaders();
+        for (Header header : httpResponse.getHeaders()) {
+            this.headers.add(header.getName(), header.getValue());
+        }
+        
+        // Buffer the response body BEFORE the ResponseHandler closes the stream
+        HttpEntity entity = httpResponse.getEntity();
+        if (entity != null) {
+            try (InputStream content = entity.getContent()) {
+                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+                byte[] chunk = new byte[8192];
+                int bytesRead;
+                while ((bytesRead = content.read(chunk)) != -1) {
+                    buffer.write(chunk, 0, bytesRead);
+                }
+                this.bodyBytes = buffer.toByteArray();
+            }
+        } else {
+            this.bodyBytes = new byte[0];
+        }
     }
 
     @Override
     public HttpStatusCode getStatusCode() throws IOException {
-        return HttpStatusCode.valueOf(httpResponse.getCode());
+        return HttpStatusCode.valueOf(statusCode);
     }
 
     @Override
     public int getRawStatusCode() throws IOException {
-        return httpResponse.getCode();
+        return statusCode;
     }
 
     @Override
     public String getStatusText() throws IOException {
-        return httpResponse.getReasonPhrase();
+        return reasonPhrase;
     }
 
     @Override
     public HttpHeaders getHeaders() {
-        if (headers == null) {
-            headers = new HttpHeaders();
-            for (Header header : httpResponse.getHeaders()) {
-                headers.add(header.getName(), header.getValue());
-            }
-        }
         return headers;
     }
 
     @Override
     public InputStream getBody() throws IOException {
-        HttpEntity entity = httpResponse.getEntity();
-        return (entity != null) ? entity.getContent() : new ByteArrayInputStream(new byte[0]);
+        return new ByteArrayInputStream(bodyBytes);
     }
 
     @Override
     public void close() {
-        // HttpClient 5.x - close the response
-        try {
-            httpResponse.close();
-        } catch (IOException e) {
-            // Ignore close exceptions
-        }
+        // Nothing to close - response was already consumed and buffered
     }
 }

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

@@ -64,46 +64,54 @@ private URI createUri(URI uri) {
         }
 
         // Build complete URI with host information from baseUri
-        UriComponentsBuilder builder = UriComponentsBuilder.newInstance()
-                .scheme(baseUri.getScheme())
-                .host(baseUri.getHost())
-                .port(baseUri.getPort());
+        // For queries with edge-case encodings (%80, %FF), we need to avoid UriComponentsBuilder
+        // validation and construct the URI string manually to preserve invalid UTF-8 sequences
+        
+        String scheme = baseUri.getScheme();
+        String host = baseUri.getHost();
+        int port = baseUri.getPort();
 
         // Handle path - combine base path with request path
         String basePath = baseUri.getPath();
         String requestPath = uri.getPath();
+        String finalPath;
 
         if (requestPath != null) {
             if (requestPath.startsWith("/")) {
                 // Absolute path - use as-is
-                builder.path(requestPath);
+                finalPath = requestPath;
             } else {
                 // Relative path - append to base path
-                String combinedPath = (basePath != null && !basePath.endsWith("/")) ? basePath + "/" + requestPath : requestPath;
-                builder.path(combinedPath);
+                finalPath = (basePath != null && !basePath.endsWith("/")) ? basePath + "/" + requestPath : requestPath;
             }
         } else {
-            builder.path(basePath);
-        }
-        
-        // Add query and fragment if present
-        if (uri.getQuery() != null) {
-            builder.query(uri.getQuery());
-        }
-        
-        if (uri.getFragment() != null) {
-            builder.fragment(uri.getFragment());
+            finalPath = basePath;
         }
 
-        URI result = builder.build().toUri();
-        
-        // Ensure the result has host information - this is critical!
-        if (result.getHost() == null) {
-            throw new IllegalStateException("Generated URI missing host information: " + result + 
-                " (baseUri: " + baseUri + ", requestUri: " + uri + ")");
+        try {
+            // Use multi-argument URI constructor to preserve exact encoding
+            // This avoids validation and re-encoding of the query string
+            URI result = new URI(
+                scheme,
+                null,  // userInfo
+                host,
+                port,
+                finalPath,
+                uri.getQuery(),
+                uri.getFragment()
+            );
+            
+            // Ensure the result has host information - this is critical!
+            if (result.getHost() == null) {
+                throw new IllegalStateException("Generated URI missing host information: " + result + 
+                    " (baseUri: " + baseUri + ", requestUri: " + uri + ")");
+            }
+            
+            return result;
+        } catch (Exception e) {
+            throw new IllegalStateException("Failed to create URI (scheme=" + scheme + ", host=" + host + 
+                ", port=" + port + ", path=" + finalPath + ", query=" + uri.getQuery() + ")", e);
         }
-        
-        return result;
     }
 
     /**