Add retry logic and conditional tests for SDKMAN API resilience

Improve test reliability in CI environments by addressing SDKMAN API
rate limiting and availability issues:

JdkResolver improvements:
- Add retry logic with exponential backoff (3 retries, 1s initial delay)
- Detect retryable errors (503, 502, 504, 429, timeouts, connection issues)
- Graceful handling of transient network failures
- Maintain existing API behavior for successful requests

Test improvements:
- Add @EnabledIf conditional execution for network-dependent tests
- Tests only run when SDKMAN API is available (prevents flaky CI failures)
- Quick API availability check with 5-second timeout
- Skip tests gracefully when API returns 503/502/504 errors

This addresses the CI flakiness caused by SDKMAN API bandwidth limiting
and intermittent 503 errors while maintaining full test coverage when
the API is available.

Author: gnodet

maven-wrapper/src/main/java/org/apache/maven/wrapper/JdkResolver.java

@@ -274,11 +274,50 @@ private JdkMetadata resolveJdkFromSdkman(String sdkmanVersion, String platform)
     }
 
     /**
-     * Makes an HTTP GET request to SDKMAN API.
-     * For download URLs: returns the redirect location (302 redirect).
-     * For version lists: returns the response body content.
+     * Makes an HTTP request with retry logic for transient failures.
+     * Returns either the redirect location (for download URLs) or response body (for version lists).
      */
     private String makeHttpRequest(String urlString) throws IOException {
+        return makeHttpRequestWithRetry(urlString, 3, 1000); // 3 retries with 1 second initial delay
+    }
+
+    /**
+     * Makes an HTTP request with configurable retry logic and exponential backoff.
+     */
+    private String makeHttpRequestWithRetry(String urlString, int maxRetries, long initialDelayMs) throws IOException {
+        IOException lastException = null;
+
+        for (int attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return performHttpRequest(urlString);
+            } catch (IOException e) {
+                lastException = e;
+
+                // Check if this is a retryable error
+                if (attempt < maxRetries && isRetryableError(e)) {
+                    long delayMs = initialDelayMs * (1L << attempt); // Exponential backoff
+                    Logger.info("SDKMAN API request failed (attempt " + (attempt + 1) + "/" + (maxRetries + 1)
+                            + "), retrying in " + delayMs + "ms: " + e.getMessage());
+
+                    try {
+                        Thread.sleep(delayMs);
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
+                        throw new IOException("Request interrupted during retry delay", ie);
+                    }
+                } else {
+                    break; // Non-retryable error or max retries reached
+                }
+            }
+        }
+
+        throw lastException;
+    }
+
+    /**
+     * Performs the actual HTTP request without retry logic.
+     */
+    private String performHttpRequest(String urlString) throws IOException {
         URL url = new URL(urlString);
         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
 
@@ -322,6 +361,31 @@ private String makeHttpRequest(String urlString) throws IOException {
         }
     }
 
+    /**
+     * Determines if an error is retryable (transient network issues, rate limiting, etc.).
+     */
+    private boolean isRetryableError(IOException e) {
+        String message = e.getMessage();
+        if (message != null) {
+            String lowerMessage = message.toLowerCase();
+            // Retry on common transient errors
+            return lowerMessage.contains("503")
+                    || // Service Unavailable
+                    lowerMessage.contains("502")
+                    || // Bad Gateway
+                    lowerMessage.contains("504")
+                    || // Gateway Timeout
+                    lowerMessage.contains("429")
+                    || // Too Many Requests
+                    lowerMessage.contains("timeout")
+                    || // Various timeout errors
+                    lowerMessage.contains("connection reset")
+                    || lowerMessage.contains("connection refused")
+                    || lowerMessage.contains("temporary failure");
+        }
+        return false;
+    }
+
     /**
      * Maps SDKMAN vendor suffix back to vendor name.
      */

maven-wrapper/src/test/java/org/apache/maven/wrapper/JdkResolverTest.java

@@ -19,8 +19,11 @@
 package org.apache.maven.wrapper;
 
 import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIf;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -29,7 +32,32 @@
  */
 class JdkResolverTest {
 
+    /**
+     * Checks if SDKMAN API is available for network-dependent tests.
+     * This prevents test failures in CI environments where the API might be unavailable.
+     */
+    static boolean isSdkmanApiAvailable() {
+        try {
+            URL url = new URL("https://api.sdkman.io/2/candidates/java/linuxx64/versions/all");
+            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+            connection.setRequestMethod("HEAD");
+            connection.setConnectTimeout(5000); // 5 second timeout
+            connection.setReadTimeout(5000);
+            connection.setRequestProperty("User-Agent", "Maven-Wrapper-Test/3.3.0");
+
+            int responseCode = connection.getResponseCode();
+            connection.disconnect();
+
+            // Consider API available if we get any response (200, 302, etc.) but not 503/502/504
+            return responseCode != 503 && responseCode != 502 && responseCode != 504;
+        } catch (Exception e) {
+            // API is not available
+            return false;
+        }
+    }
+
     @Test
+    @EnabledIf("isSdkmanApiAvailable")
     void testResolveTemurinJdk() throws IOException {
         JdkResolver resolver = new JdkResolver();
 
@@ -43,6 +71,7 @@ void testResolveTemurinJdk() throws IOException {
     }
 
     @Test
+    @EnabledIf("isSdkmanApiAvailable")
     void testResolveJdkWithDefaultVendor() throws IOException {
         JdkResolver resolver = new JdkResolver();
 
@@ -67,6 +96,7 @@ void testResolveJdkWithInvalidVersion() {
     }
 
     @Test
+    @EnabledIf("isSdkmanApiAvailable")
     void testResolveJdkWithUnsupportedVendor() {
         JdkResolver resolver = new JdkResolver();
 
@@ -80,12 +110,13 @@ void testResolveJdkWithUnsupportedVendor() {
     }
 
     @Test
+    @EnabledIf("isSdkmanApiAvailable")
     void testResolveMajorVersionQueriesApi() throws IOException {
         JdkResolver resolver = new JdkResolver();
 
         // Test that major version resolution actually queries SDKMAN API
-        // This test will make a real API call - in a production test suite,
-        // you might want to mock this
+        // This test makes a real API call but is conditional on API availability
+        // to prevent flaky failures in CI environments
         JdkResolver.JdkMetadata metadata = resolver.resolveJdk("17", "temurin");
 
         assertNotNull(metadata);