JIRA:GRIF-316 upgrade 1

Author: alexole01

README.md

@@ -1,17 +1,30 @@
 # GoodData HTTP Client
 [![Build Status](https://github.com/gooddata/gooddata-http-client/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/gooddata/gooddata-http-client/actions/workflows/build.yml) [![Javadocs](http://javadoc.io/badge/com.gooddata/gooddata-http-client.svg)](http://javadoc.io/doc/com.gooddata/gooddata-http-client) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.gooddata/gooddata-http-client/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.gooddata/gooddata-http-client) [![Release](https://img.shields.io/github/v/release/gooddata/gooddata-http-client.svg)](https://search.maven.org/artifact/com.gooddata/gooddata-http-client)
 
-GoodData HTTP Client is an extension of [Apache HTTP Client](http://hc.apache.org/httpcomponents-client-4.3.x/index.html) (former Jakarta Commons).
+GoodData HTTP Client is an extension of [Apache HTTP Client 5.x](https://hc.apache.org/httpcomponents-client-5.3.x/index.html).
 This specialized Java client transparently handles [GoodData authentication](https://help.gooddata.com/display/doc/API+Reference#/reference/authentication/log-in)
 so you can focus on writing logic on top of [GoodData API](https://help.gooddata.com/display/doc/API+Reference).
 
+## ⚠️ Version 2.0+ Breaking Changes
+
+**Version 2.0.0** introduces a major update migrating from Apache HttpClient 4.x to 5.x. See the [Migration Guide](#migration-guide) below for upgrade instructions.
+
+## Requirements
+
+- **Java 17+** (updated from Java 8)
+- **Apache HttpClient 5.5+** (migrated from 4.x)
+- **Maven 3.6+** (for building)
+
 ## Design
 
-```com.gooddata.http.client.GoodDataHttpClient``` central class implements [org.apache.http.client.HttpClient interface](http://hc.apache.org/httpcomponents-client-4.2.x/httpclient/apidocs/org/apache/http/client/HttpClient.html)
-It allows seamless switch for existing code base currently using ```org.apache.http.client.HttpClient```. Business logic encapsulating
-access to [GoodData API](https://help.gooddata.com/display/doc/API+Reference) should use ```org.apache.http.client.HttpClient``` interface
-and keep ```com.gooddata.http.client.GoodDataHttpClient``` inside a factory class. ```com.gooddata.http.client.GoodDataHttpClient``` uses underlying ```org.apache.http.client.HttpClient```.  A HTTP client
-instance can be passed via the constructor.
+`com.gooddata.http.client.GoodDataHttpClient` is a thread-safe HTTP client that wraps Apache HttpClient 5.x and provides transparent GoodData authentication handling. The client automatically manages SST (Super Secure Token) and TT (Temporary Token) lifecycle, including:
+
+- Automatic token refresh on expiration
+- Retry logic for authentication failures  
+- Thread-safe token management
+- Support for all HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+
+Business logic should use the `GoodDataHttpClient` class directly, which handles all authentication concerns internally.
 
 ## Usage
 
@@ -32,52 +45,190 @@ If your project is managed by Maven you can add GoodData HTTP client as a new de
 
 ### <a name="credentials"/>Authentication using credentials</a>
 
-```Java
-import com.gooddata.http.client.*
-import java.io.IOException;
-import org.apache.http.*;
+```java
+import com.gooddata.http.client.*;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.*;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
 
-HttpHost hostGoodData = new HttpHost("secure.gooddata.com", 443, "https");
+HttpHost hostGoodData = new HttpHost("https", "secure.gooddata.com", 443);
 
-// create login strategy, which will obtain SST via credentials
+// Create login strategy, which will obtain SST via credentials
 SSTRetrievalStrategy sstStrategy = new LoginSSTRetrievalStrategy(login, password);
 
-HttpClient client = new GoodDataHttpClient(HttpClientBuilder.create().build(), hostGoodData, sstStrategy);
+// Create GoodData HTTP client
+GoodDataHttpClient client = new GoodDataHttpClient(
+    HttpClients.createDefault(), 
+    hostGoodData, 
+    sstStrategy
+);
 
-// use HTTP client with transparent GoodData authentication
+// Use HTTP client with transparent GoodData authentication
 HttpGet getProject = new HttpGet("/gdc/projects");
 getProject.addHeader("Accept", ContentType.APPLICATION_JSON.getMimeType());
-HttpResponse getProjectResponse = client.execute(hostGoodData, getProject);
+ClassicHttpResponse getProjectResponse = client.execute(hostGoodData, getProject);
 
 System.out.println(EntityUtils.toString(getProjectResponse.getEntity()));
 ```
 
 ### <a name="sst"/>Authentication using super-secure token (SST)</a>
 
-```Java
-import com.gooddata.http.client.*
-import java.io.IOException;
-import org.apache.http.*;
-
-// create HTTP client
-HttpClient httpClient = HttpClientBuilder.create().build();
+```java
+import com.gooddata.http.client.*;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.*;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
 
-HttpHost hostGoodData = new HttpHost("secure.gooddata.com", 443, "https");
+HttpHost hostGoodData = new HttpHost("https", "secure.gooddata.com", 443);
 
-// create login strategy (you must somehow obtain SST)
+// Create login strategy (you must somehow obtain SST)
 SSTRetrievalStrategy sstStrategy = new SimpleSSTRetrievalStrategy("my super-secure token");
 
-// wrap your HTTP client into GoodData HTTP client
-HttpClient client = new GoodDataHttpClient(httpClient, hostGoodData, sstStrategy);
+// Create GoodData HTTP client
+GoodDataHttpClient client = new GoodDataHttpClient(
+    HttpClients.createDefault(), 
+    hostGoodData, 
+    sstStrategy
+);
 
-// use GoodData HTTP client
+// Use GoodData HTTP client
 HttpGet getProject = new HttpGet("/gdc/projects");
 getProject.addHeader("Accept", ContentType.APPLICATION_JSON.getMimeType());
-HttpResponse getProjectResponse = client.execute(hostGoodData, getProject);
+ClassicHttpResponse getProjectResponse = client.execute(hostGoodData, getProject);
 
 System.out.println(EntityUtils.toString(getProjectResponse.getEntity()));
 ```
 
+## Migration Guide
+
+### Migrating from 1.x to 2.0+ (Apache HttpClient 4.x to 5.x)
+
+Version 2.0.0 introduces breaking changes due to the Apache HttpClient 5.x migration. Follow these steps to upgrade:
+
+#### 1. Update Dependencies
+
+**Maven:**
+```xml
+<dependency>
+  <groupId>com.gooddata</groupId>
+  <artifactId>gooddata-http-client</artifactId>
+  <version>2.0.0</version> <!-- Updated from 1.x -->
+</dependency>
+```
+
+#### 2. Update Java Version
+
+Ensure your project uses **Java 17 or higher**:
+```xml
+<maven.compiler.source>17</maven.compiler.source>
+<maven.compiler.target>17</maven.compiler.target>
+```
+
+#### 3. Update Imports
+
+Replace Apache HttpClient 4.x imports with 5.x equivalents:
+
+**Before (1.x):**
+```java
+import org.apache.http.HttpHost;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+```
+
+**After (2.0+):**
+```java
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.ClassicHttpResponse;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+```
+
+#### 4. Update HttpHost Construction
+
+**Before (1.x):**
+```java
+HttpHost host = new HttpHost("secure.gooddata.com", 443, "https");
+```
+
+**After (2.0+):**
+```java
+HttpHost host = new HttpHost("https", "secure.gooddata.com", 443);
+// Note: scheme is now the first parameter
+```
+
+#### 5. Update Response Handling
+
+**Before (1.x):**
+```java
+HttpResponse response = client.execute(host, request);
+```
+
+**After (2.0+):**
+```java
+ClassicHttpResponse response = client.execute(host, request);
+```
+
+#### 6. Update HttpClient Creation
+
+**Before (1.x):**
+```java
+HttpClient httpClient = HttpClientBuilder.create().build();
+```
+
+**After (2.0+):**
+```java
+HttpClient httpClient = HttpClients.createDefault();
+// Or with custom configuration:
+HttpClient httpClient = HttpClients.custom()
+    .setDefaultRequestConfig(RequestConfig.custom()
+        .setConnectionRequestTimeout(Timeout.ofSeconds(30))
+        .build())
+    .build();
+```
+
+#### 7. Key Behavioral Changes
+
+- **Thread Safety**: All requests now use write locks for consistency. This may reduce throughput under high concurrency but ensures reliable token management.
+- **Entity Handling**: Non-repeatable request entities are automatically buffered for retry scenarios.
+- **Error Handling**: More specific exceptions for authentication failures.
+- **HTTP Methods**: Full support for POST, PUT, PATCH in addition to GET and DELETE.
+
+#### 8. Testing Your Migration
+
+After updating your code:
+
+1. **Compile**: Ensure no compilation errors
+2. **Test**: Run your existing test suite
+3. **Integration Test**: Test against GoodData API with real credentials
+4. **Monitor**: Watch for authentication issues or performance changes
+
+#### Common Migration Issues
+
+**Issue: NoClassDefFoundError**
+- **Cause**: Conflicting HttpClient versions in classpath
+- **Fix**: Use `mvn dependency:tree` to identify conflicts and exclude old HttpClient 4.x dependencies
+
+**Issue: Method not found errors**
+- **Cause**: Using old HttpClient 4.x APIs
+- **Fix**: Update all imports and method calls to HttpClient 5.x equivalents
+
+**Issue: Authentication failures**
+- **Cause**: Token handling differences
+- **Fix**: Ensure SST/TT tokens are being passed correctly; check logs for authentication errors
+
+### Need Help?
+
+- Review the [complete API documentation](http://javadoc.io/doc/com.gooddata/gooddata-http-client)
+- Check [Apache HttpClient 5.x migration guide](https://hc.apache.org/httpcomponents-client-5.3.x/migration-guide/index.html)
+- Report issues on [GitHub](https://github.com/gooddata/gooddata-http-client/issues)
+
 ## Build
 
 ```

pom.xml

@@ -164,7 +164,6 @@
                 <version>3.2.5</version>
                 <configuration>
                     <useModulePath>false</useModulePath>
-                <!--    <skip>true</skip> -->
                 </configuration>
             </plugin>
         </plugins>

src/main/java/com/gooddata/http/client/GoodDataHttpClient.java

@@ -116,6 +116,10 @@ private ClassicHttpResponse handleResponse(
                         throw new IOException("Interrupted while waiting for token refresh", e);
                     }
                 }
+                // After waiting, verify that tt was successfully obtained
+                if (tt == null) {
+                    throw new GoodDataAuthException("Token refresh completed but TT is still null");
+                }
                 final ClassicHttpRequest retryRequest = cloneRequestWithNewTT(originalRequest, tt);
                 return this.httpClient.execute(httpHost, retryRequest, context, response -> copyResponseEntity(response));
             } else {
@@ -160,28 +164,93 @@ private ClassicHttpResponse handleResponse(
         return retryResponse;
     }
 
-    private ClassicHttpRequest cloneRequestWithNewTT(ClassicHttpRequest original, String newTT) {
+    private ClassicHttpRequest cloneRequestWithNewTT(ClassicHttpRequest original, String newTT) throws IOException {
         ClassicHttpRequest copy;
-        // Clone basic types (extend if needed)
+        
+        // Clone request based on method type
         switch (original.getMethod()) {
             case "GET":
                 copy = new HttpGet(original.getRequestUri());
                 break;
+            case "POST":
+                copy = cloneRequestWithEntity(
+                    new org.apache.hc.client5.http.classic.methods.HttpPost(original.getRequestUri()),
+                    original
+                );
+                break;
+            case "PUT":
+                copy = cloneRequestWithEntity(
+                    new org.apache.hc.client5.http.classic.methods.HttpPut(original.getRequestUri()),
+                    original
+                );
+                break;
+            case "PATCH":
+                copy = cloneRequestWithEntity(
+                    new org.apache.hc.client5.http.classic.methods.HttpPatch(original.getRequestUri()),
+                    original
+                );
+                break;
             case "DELETE":
                 copy = new org.apache.hc.client5.http.classic.methods.HttpDelete(original.getRequestUri());
                 break;
+            case "HEAD":
+                copy = new org.apache.hc.client5.http.classic.methods.HttpHead(original.getRequestUri());
+                break;
+            case "OPTIONS":
+                copy = new org.apache.hc.client5.http.classic.methods.HttpOptions(original.getRequestUri());
+                break;
             default:
                 throw new UnsupportedOperationException("Unsupported HTTP method: " + original.getMethod());
         }
+        
         // Copy original headers
         for (Header header : original.getHeaders()) {
             copy.addHeader(header.getName(), header.getValue());
         }
+        
         // Set the new TT
         copy.addHeader(TT_HEADER, newTT);
         return copy;
     }
 
+    /**
+     * Helper method to clone request entity safely, handling both repeatable and non-repeatable entities.
+     * For non-repeatable entities, buffers the content to allow reuse.
+     */
+    private <T extends ClassicHttpRequest> T cloneRequestWithEntity(T target, ClassicHttpRequest source) throws IOException {
+        if (!(source instanceof org.apache.hc.core5.http.HttpEntityContainer)) {
+            return target;
+        }
+        
+        org.apache.hc.core5.http.HttpEntity entity = 
+            ((org.apache.hc.core5.http.HttpEntityContainer) source).getEntity();
+        
+        if (entity == null) {
+            return target;
+        }
+        
+        // Check if entity is repeatable - if so, we can reuse it directly
+        if (entity.isRepeatable()) {
+            if (target instanceof org.apache.hc.core5.http.HttpEntityContainer) {
+                ((org.apache.hc.core5.http.HttpEntityContainer) target).setEntity(entity);
+            }
+        } else {
+            // Entity is not repeatable - buffer it for reuse
+            log.debug("Buffering non-repeatable entity for retry");
+            byte[] content = EntityUtils.toByteArray(entity);
+            String contentTypeStr = entity.getContentType();
+            ContentType contentType = contentTypeStr != null ? 
+                ContentType.parseLenient(contentTypeStr) : ContentType.DEFAULT_BINARY;
+            
+            ByteArrayEntity bufferedEntity = new ByteArrayEntity(content, contentType);
+            if (target instanceof org.apache.hc.core5.http.HttpEntityContainer) {
+                ((org.apache.hc.core5.http.HttpEntityContainer) target).setEntity(bufferedEntity);
+            }
+        }
+        
+        return target;
+    }
+
     private boolean refreshTt() throws IOException {
         log.debug("Obtaining TT");
         final HttpGet request = new HttpGet(TOKEN_URL);
@@ -212,7 +281,11 @@ private boolean refreshTt() throws IOException {
      */
     public ClassicHttpResponse execute(HttpHost target, ClassicHttpRequest request, HttpContext context) throws IOException {
         notNull(request, "Request can't be null");
-        // FIX: use only writeLock to avoid deadlock during handleResponse
+        // Using write lock for all requests to prevent deadlock scenarios where:
+        // 1. Thread A holds read lock and calls handleResponse (needs write lock)
+        // 2. Thread B waits for write lock to refresh tokens
+        // 3. Deadlock occurs as Thread A can't upgrade from read to write lock
+        // Trade-off: Serializes all requests but ensures thread safety during token refresh
         final Lock lock = rwLock.writeLock();
         lock.lock();
         try {
@@ -256,8 +329,7 @@ public ClassicHttpResponse execute(HttpHost target, ClassicHttpRequest request,
     }
 
     public ClassicHttpResponse execute(HttpHost target, ClassicHttpRequest request) throws IOException {
-       //  return httpClient.execute(target, request, (HttpContext) null, response -> response);
-       return execute(target, request, null);
+        return execute(target, request, null);
     }
 
     public <T> T execute(HttpHost target, ClassicHttpRequest request, HttpContext context,
@@ -284,7 +356,9 @@ private ClassicHttpResponse copyResponseEntity(ClassicHttpResponse response) thr
 
         // Copy the entity content
         byte[] content = EntityUtils.toByteArray(response.getEntity());
-        ContentType contentType = ContentType.parseLenient(response.getEntity().getContentType());
+        String contentTypeStr = response.getEntity().getContentType();
+        ContentType contentType = contentTypeStr != null ? 
+            ContentType.parseLenient(contentTypeStr) : ContentType.DEFAULT_BINARY;
 
         // Create a new response with copied entity
         BasicClassicHttpResponse newResponse = new BasicClassicHttpResponse(response.getCode(), response.getReasonPhrase());