Add retry support for HTTP 503 and 429 in Java11HttpTransport

Co-authored-by: laeubi <1331477+laeubi@users.noreply.github.com>

Author: Copilot

p2-maven-plugin/src/main/java/org/eclipse/tycho/p2maven/transport/Java11HttpTransportFactory.java

@@ -67,6 +67,9 @@ public class Java11HttpTransportFactory implements HttpTransportFactory, Initial
 			ThreadLocal.withInitial(() -> new SimpleDateFormat("EEE MMMd HH:mm:ss yyyy", Locale.ENGLISH)));
 
 	static final String HINT = "Java11Client";
+	private static final int MAX_RETRY_ATTEMPTS = 5;
+	private static final int DEFAULT_RETRY_DELAY_SECONDS = 5;
+	
 	@Requirement
 	ProxyHelper proxyHelper;
 	@Requirement
@@ -124,47 +127,106 @@ public <T> T get(ResponseConsumer<T> consumer) throws IOException {
 				throw new InterruptedIOException();
 			}
 		}
+		
+		private boolean shouldRetry(int statusCode) {
+			return statusCode == 503 || statusCode == 429;
+		}
+		
+		private long getRetryDelay(HttpResponse<?> response) {
+			String retryAfterHeader = response.headers().firstValue("Retry-After").orElse(null);
+			if (retryAfterHeader == null || retryAfterHeader.isBlank()) {
+				return DEFAULT_RETRY_DELAY_SECONDS;
+			}
+			
+			// Try to parse as seconds (integer)
+			if (Character.isDigit(retryAfterHeader.charAt(0))) {
+				try {
+					return Long.parseLong(retryAfterHeader.trim());
+				} catch (NumberFormatException e) {
+					// Fall through to date parsing
+				}
+			}
+			
+			// Try to parse as HTTP date
+			for (ThreadLocal<DateFormat> dateFormat : DATE_PATTERNS) {
+				try {
+					long retryTime = dateFormat.get().parse(retryAfterHeader).getTime();
+					long currentTime = System.currentTimeMillis();
+					long delayMillis = retryTime - currentTime;
+					if (delayMillis > 0) {
+						return TimeUnit.MILLISECONDS.toSeconds(delayMillis);
+					}
+				} catch (ParseException e) {
+					// Try next pattern
+				}
+			}
+			
+			// Default if parsing fails
+			return DEFAULT_RETRY_DELAY_SECONDS;
+		}
 
 		private <T> T performGet(ResponseConsumer<T> consumer, HttpClient httpClient)
 				throws IOException, InterruptedException {
-			HttpRequest request = builder.GET().timeout(Duration.ofSeconds(TIMEOUT_SECONDS)).build();
-			HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
-			try (ResponseImplementation<InputStream> implementation = new ResponseImplementation<>(response) {
-
-				@Override
-				public void close() {
-					if (response.version() == Version.HTTP_1_1) {
-						// discard any remaining data and close the stream to return the connection to
-						// the pool..
-						try (InputStream stream = response.body()) {
-							int discarded = 0;
-							while (discarded < MAX_DISCARD) {
-								int read = stream.read(DUMMY_BUFFER);
-								if (read < 0) {
-									break;
+			int retriesLeft = MAX_RETRY_ATTEMPTS;
+			while (retriesLeft > 0) {
+				retriesLeft--;
+				HttpRequest request = builder.GET().timeout(Duration.ofSeconds(TIMEOUT_SECONDS)).build();
+				HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+				
+				int statusCode = response.statusCode();
+				if (shouldRetry(statusCode) && retriesLeft > 0) {
+					long delaySeconds = getRetryDelay(response);
+					logger.info("Server returned status " + statusCode + " for " + uri 
+							+ ", waiting " + delaySeconds + " seconds before retry. " 
+							+ retriesLeft + " retries left.");
+					// Close the response stream before retrying
+					try (InputStream stream = response.body()) {
+						// Discard any content
+					} catch (IOException e) {
+						// Ignore
+					}
+					TimeUnit.SECONDS.sleep(delaySeconds);
+					continue;
+				}
+				
+				try (ResponseImplementation<InputStream> implementation = new ResponseImplementation<>(response) {
+
+					@Override
+					public void close() {
+						if (response.version() == Version.HTTP_1_1) {
+							// discard any remaining data and close the stream to return the connection to
+							// the pool..
+							try (InputStream stream = response.body()) {
+								int discarded = 0;
+								while (discarded < MAX_DISCARD) {
+									int read = stream.read(DUMMY_BUFFER);
+									if (read < 0) {
+										break;
+									}
+									discarded += read;
 								}
-								discarded += read;
+							} catch (IOException e) {
+								// don't care...
+							}
+						} else {
+							// just closing should be enough to signal to the framework...
+							try (InputStream stream = response.body()) {
+							} catch (IOException e) {
+								// don't care...
 							}
-						} catch (IOException e) {
-							// don't care...
-						}
-					} else {
-						// just closing should be enough to signal to the framework...
-						try (InputStream stream = response.body()) {
-						} catch (IOException e) {
-							// don't care...
 						}
 					}
-				}
 
-				@Override
-				public void transferTo(OutputStream outputStream, ContentEncoding transportEncoding)
-						throws IOException {
-					transportEncoding.decode(response.body()).transferTo(outputStream);
+					@Override
+					public void transferTo(OutputStream outputStream, ContentEncoding transportEncoding)
+							throws IOException {
+						transportEncoding.decode(response.body()).transferTo(outputStream);
+					}
+				}) {
+					return consumer.handleResponse(implementation);
 				}
-			}) {
-				return consumer.handleResponse(implementation);
 			}
+			throw new IOException("Maximum retry attempts exceeded for " + uri);
 		}
 
 		@Override
@@ -187,22 +249,38 @@ public Response head() throws IOException {
 		}
 
 		private Response doHead(HttpClient httpClient) throws IOException, InterruptedException {
-			HttpResponse<Void> response = httpClient.send(
-					builder.method("HEAD", BodyPublishers.noBody()).timeout(Duration.ofSeconds(TIMEOUT_SECONDS))
-							.build(),
-					BodyHandlers.discarding());
-			return new ResponseImplementation<>(response) {
-				@Override
-				public void close() {
-					// nothing...
+			int retriesLeft = MAX_RETRY_ATTEMPTS;
+			while (retriesLeft > 0) {
+				retriesLeft--;
+				HttpResponse<Void> response = httpClient.send(
+						builder.method("HEAD", BodyPublishers.noBody()).timeout(Duration.ofSeconds(TIMEOUT_SECONDS))
+								.build(),
+						BodyHandlers.discarding());
+				
+				int statusCode = response.statusCode();
+				if (shouldRetry(statusCode) && retriesLeft > 0) {
+					long delaySeconds = getRetryDelay(response);
+					logger.info("Server returned status " + statusCode + " for HEAD " + uri 
+							+ ", waiting " + delaySeconds + " seconds before retry. " 
+							+ retriesLeft + " retries left.");
+					TimeUnit.SECONDS.sleep(delaySeconds);
+					continue;
 				}
+				
+				return new ResponseImplementation<>(response) {
+					@Override
+					public void close() {
+						// nothing...
+					}
 
-				@Override
-				public void transferTo(OutputStream outputStream, ContentEncoding transportEncoding)
-						throws IOException {
-					throw new IOException("HEAD returns no body");
-				}
-			};
+					@Override
+					public void transferTo(OutputStream outputStream, ContentEncoding transportEncoding)
+							throws IOException {
+						throw new IOException("HEAD returns no body");
+					}
+				};
+			}
+			throw new IOException("Maximum retry attempts exceeded for HEAD " + uri);
 		}
 
 	}