fix(retry): drop Retry.java; revert createBody bracket per r3206778779

Three changes:

(1) Retry.java is folded into Http.RetryInterceptor as package-private
static members (MAX_RETRY, DEFAULT_RETRY_UNIT_MS, DEFAULT_RETRY_CAP_MS,
MAX_JITTER, RETRYABLE_HTTP_STATUS_CODES, isHttpStatusRetryable,
isRequestErrorRetryable, exponentialBackoffMs). The class was a one-use
container for the interceptor's helpers; folding shrinks the package
surface. RetryTest call sites updated to Http.RetryInterceptor.X.

(2) BaseS3Client.createBody save/restore bracket dropped (r3206778779,
"It is not needed for Java"). For the file-PUT paths that go through
MinioAsyncClient, the upstream brackets at L1995/L3540 leave the file
pointer at start-of-payload, and the pre-computed Checksum.makeHeaders
headers short-circuit every Checksum.update guard inside createBody --
so the pointer never moves there. Http.RequestBody.writeTo seeks to
the captured start-of-payload on every attempt, so the retry
interceptor's repeated writeTo calls replay the same bytes. createBody
is now byte-identical to master.

(3) Checksum.java reverted to master form. The positional
FileChannel.read(ByteBuffer, long) variant added in 93e4f47 exists
only to make the bracket in createBody redundant; once the bracket is
gone, the variant is no longer needed and Checksum.update returns to
the master file.read(buf, off, len) form. MinioAsyncClient L1995/L3540
brackets remain (they match master verbatim).

Empirical validation -- two new tests in RetryTest:
- testRetryWithFileBody_replaysSameBytesOnEveryAttempt: 8 KiB random
  payload, MockWebServer queue 503/503/503/200; asserts 4 PUT requests
  recorded and each body is byte-identical to the original payload.
- testRetryWithFileBody_transportFailureReplaysFromStart: 4 KiB
  payload, DISCONNECT_AT_START followed by 200; asserts the retry
  attempt's body matches the original payload after seek-back.

:api:check (compile + spotless + spotbugs + 30 RetryTest cases) PASS
:api:javadoc PASS

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: allanrogerr

api/src/main/java/io/minio/BaseS3Client.java

@@ -118,7 +118,7 @@ public abstract class BaseS3Client implements AutoCloseable {
    * Maximum attempts per S3 request. Effective only on the SDK-default {@link OkHttpClient};
    * caller-supplied clients are used verbatim and the SDK does not modify their retry policy.
    */
-  volatile int maxRetries = Retry.MAX_RETRY;
+  volatile int maxRetries = Http.RetryInterceptor.MAX_RETRY;
 
   protected BaseS3Client(
       Http.BaseUrl baseUrl, Provider provider, OkHttpClient httpClient, boolean closeHttpClient) {

api/src/main/java/io/minio/Checksum.java

@@ -104,31 +104,12 @@ private static void update(
       size = buffer.length();
     }
 
-    // Positional reads keep this method side-effect-free on the file pointer; callers don't need
-    // to bracket with seek/restore.
-    long filePos = 0L;
-    java.nio.channels.FileChannel channel = null;
-    if (file != null) {
-      try {
-        filePos = file.getFilePointer();
-        channel = file.getChannel();
-      } catch (IOException e) {
-        throw new MinioException(e);
-      }
-    }
-
     byte[] buf16k = new byte[16384];
     long bytesRead = 0;
     while (bytesRead != size) {
       try {
         int length = (int) Math.min(size - bytesRead, buf16k.length);
-        int n;
-        if (file != null) {
-          java.nio.ByteBuffer dst = java.nio.ByteBuffer.wrap(buf16k, 0, length);
-          n = channel.read(dst, filePos + bytesRead);
-        } else {
-          n = stream.read(buf16k, 0, length);
-        }
+        int n = file != null ? file.read(buf16k, 0, length) : stream.read(buf16k, 0, length);
         if (n < 0) throw new MinioException("unexpected EOF");
         if (n != 0) {
           bytesRead += n;

api/src/main/java/io/minio/Http.java

@@ -35,6 +35,8 @@
 import java.security.KeyStoreException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
+import java.security.cert.CertPathBuilderException;
+import java.security.cert.CertPathValidatorException;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
@@ -52,6 +54,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.function.IntSupplier;
 import java.util.regex.Matcher;
@@ -61,6 +64,9 @@
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManager;
@@ -611,11 +617,12 @@ public static OkHttpClient enableExternalCertificatesFromEnv(OkHttpClient client
   }
 
   /**
-   * Creates the SDK's default HTTP client with a fixed retry budget of {@link Retry#MAX_RETRY}. For
-   * a runtime-tunable budget, use {@link #newDefaultClient(IntSupplier)}.
+   * Creates the SDK's default HTTP client with a fixed retry budget of {@link
+   * RetryInterceptor#MAX_RETRY}. For a runtime-tunable budget, use {@link
+   * #newDefaultClient(IntSupplier)}.
    */
   public static OkHttpClient newDefaultClient() {
-    return newDefaultClient(() -> Retry.MAX_RETRY);
+    return newDefaultClient(() -> RetryInterceptor.MAX_RETRY);
   }
 
   /**
@@ -736,11 +743,85 @@ public static OkHttpClient setTimeout(
    * deliberately does not, in exchange for a simpler interceptor model.)
    */
   public static class RetryInterceptor implements Interceptor {
+    /** Default maximum number of attempts per request. */
+    static final int MAX_RETRY = 10;
+
+    /** Base unit per retry attempt, in milliseconds. */
+    static final long DEFAULT_RETRY_UNIT_MS = 200L;
+
+    /** Per-attempt sleep cap, in milliseconds. */
+    static final long DEFAULT_RETRY_CAP_MS = 1_000L;
+
+    /** Maximum jitter fraction in {@code [0.0, 1.0]}. {@code 1.0} = full jitter. */
+    static final double MAX_JITTER = 1.0;
+
+    /** Retryable HTTP status codes. */
+    static final Set<Integer> RETRYABLE_HTTP_STATUS_CODES =
+        ImmutableSet.of(
+            408, // Request Timeout
+            429, // Too Many Requests
+            499, // Client Closed Request (nginx)
+            500, // Internal Server Error
+            502, // Bad Gateway
+            503, // Service Unavailable
+            504, // Gateway Timeout
+            520); // Cloudflare unknown error
+
+    static boolean isHttpStatusRetryable(int code) {
+      return RETRYABLE_HTTP_STATUS_CODES.contains(code);
+    }
+
+    /**
+     * Returns true if {@code e} represents a transient transport failure that should be retried.
+     * TLS handshake failure, unknown-CA / cert-path errors, and the "server gave HTTP response to
+     * HTTPS client" protocol mismatch are NOT retryable; everything else (connection reset, EOF,
+     * server closed idle connection, socket timeout, …) is.
+     */
+    static boolean isRequestErrorRetryable(IOException e) {
+      if (e instanceof SSLHandshakeException) return false;
+      if (e instanceof SSLPeerUnverifiedException) return false;
+      if (e instanceof SSLException) {
+        Throwable cause = e.getCause();
+        if (cause instanceof CertPathBuilderException
+            || cause instanceof CertPathValidatorException
+            || cause instanceof CertificateException) {
+          return false;
+        }
+      }
+      String msg = e.getMessage();
+      if (msg != null && msg.contains("server gave HTTP response to HTTPS client")) return false;
+      return true;
+    }
+
+    /**
+     * Computes the exponential-backoff-with-full-jitter delay for retry {@code attempt} (0-indexed:
+     * {@code 0} = before the second attempt, {@code 1} = before the third, …):
+     *
+     * <pre>
+     *   sleep = min(DEFAULT_RETRY_CAP_MS, DEFAULT_RETRY_UNIT_MS * 2^attempt)
+     *   sleep -= (long)(random.nextDouble() * sleep * MAX_JITTER)   // full jitter when MAX_JITTER == 1.0
+     * </pre>
+     *
+     * <p>With {@code MAX_JITTER == 1.0}, returns a value in {@code [1, min(cap, base *
+     * 2^attempt)]}. The lower bound is {@code 1} rather than {@code 0} because {@link
+     * java.util.concurrent.ThreadLocalRandom#nextDouble()} is in {@code [0.0, 1.0)} and the {@code
+     * (long)} cast truncates {@code rand * sleep} to at most {@code sleep - 1}. This matches the
+     * behaviour of minio-go's {@code exponentialBackoffWait}, which uses the same formula and
+     * therefore the same bounds.
+     */
+    static long exponentialBackoffMs(int attempt) {
+      int exp = Math.min(Math.max(attempt, 0), 30);
+      long sleep = DEFAULT_RETRY_UNIT_MS * (1L << exp);
+      if (sleep > DEFAULT_RETRY_CAP_MS) sleep = DEFAULT_RETRY_CAP_MS;
+      sleep -= (long) (ThreadLocalRandom.current().nextDouble() * (double) sleep * MAX_JITTER);
+      return Math.max(0L, sleep);
+    }
+
     private final IntSupplier maxAttemptsSupplier;
 
-    /** Uses a fixed budget of {@link Retry#MAX_RETRY} attempts. */
+    /** Uses a fixed budget of {@link #MAX_RETRY} attempts. */
     public RetryInterceptor() {
-      this(() -> Retry.MAX_RETRY);
+      this(() -> MAX_RETRY);
     }
 
     /**
@@ -769,7 +850,7 @@ public okhttp3.Response intercept(Chain chain) throws IOException {
         }
 
         if (attempt > 0) {
-          long delayMs = Retry.exponentialBackoffMs(attempt - 1);
+          long delayMs = exponentialBackoffMs(attempt - 1);
           if (delayMs > 0L) {
             try {
               Thread.sleep(delayMs);
@@ -791,12 +872,12 @@ public okhttp3.Response intercept(Chain chain) throws IOException {
           // A cancelled call surfaces as IOException with a message that would
           // otherwise pass `isRequestErrorRetryable`. Bail out instead.
           if (chain.call().isCanceled()) throw e;
-          if (!Retry.isRequestErrorRetryable(e)) throw e;
+          if (!isRequestErrorRetryable(e)) throw e;
           lastException = e;
           continue;
         }
 
-        if (Retry.isHttpStatusRetryable(response.code())) {
+        if (isHttpStatusRetryable(response.code())) {
           lastException = null;
           continue;
         }

api/src/main/java/io/minio/MinioAsyncClient.java

@@ -156,7 +156,7 @@ public static final class Builder {
     private Provider provider;
     private OkHttpClient httpClient;
     private boolean closeHttpClient;
-    private int maxRetries = Retry.MAX_RETRY;
+    private int maxRetries = Http.RetryInterceptor.MAX_RETRY;
 
     public Builder baseUrl(Http.BaseUrl baseUrl) {
       if (baseUrl.region() == null) {
@@ -1993,7 +1993,9 @@ private CompletableFuture<ObjectWriteResponse> putObject(
         Map<Checksum.Algorithm, Checksum.Hasher> hashers = Checksum.newHasherMap(algorithms);
 
         if (file != null) {
+          long position = file.getFilePointer();
           Checksum.update(hashers, file, length);
+          file.seek(position);
           return putObject(
               new PutObjectAPIArgs(
                   args,
@@ -2013,6 +2015,8 @@ private CompletableFuture<ObjectWriteResponse> putObject(
                 Checksum.makeHeaders(hashers, addContentSha256, addSha256Checksum)));
       } catch (MinioException e) {
         return Utils.failedFuture(e);
+      } catch (IOException e) {
+        return Utils.failedFuture(new MinioException(e));
       }
     }
 
@@ -3540,9 +3544,13 @@ private CompletableFuture<ObjectWriteResponse> appendObject(
       }
 
       try {
+        long position = file.getFilePointer();
         Checksum.update(hashers, file, size);
+        file.seek(position);
       } catch (MinioException e) {
         return Utils.failedFuture(e);
+      } catch (IOException e) {
+        return Utils.failedFuture(new MinioException(e));
       }
 
       headers.putAll(Checksum.makeHeaders(hashers, addContentSha256, addSha256Checksum));