From c5ed15eaad178303c99b63d028637901a39a9740 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 22 Jul 2025 18:15:56 -0400
Subject: [PATCH 01/41] exploration

---
 .../async/FileAsyncResponseTransformer.java   | 129 ++--------------
 .../async/FileSplittingTransformer.java       |  19 +++
 .../core/internal/async/FileSubscriber.java   | 141 ++++++++++++++++++
 .../internal/async/FileSubscriberTckTest.java |   1 -
 .../progress/TransferProgressUpdater.java     |   1 +
 .../progress/ContentRangeParserTest.java      |  17 ++-
 .../multipart/DownloadObjectHelper.java       |   4 +
 ...MultipartFileAsyncResponseTransformer.java |  54 +++++++
 .../4195d6e3-8849-4e5a-848d-04f810577cd3      |   2 +-
 .../awssdk/utils}/ContentRangeParser.java     |  35 ++++-
 .../amazon/awssdk/utils/ToString.java         |   1 +
 11 files changed, 282 insertions(+), 122 deletions(-)
 create mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java
 create mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java
 create mode 100644 services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
 rename {services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress => utils/src/main/java/software/amazon/awssdk/utils}/ContentRangeParser.java (71%)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 4348355fa5d8..b3fc0babe791 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -23,7 +23,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.AsynchronousFileChannel;
-import java.nio.channels.CompletionHandler;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.OpenOption;
@@ -34,18 +33,17 @@
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.FileTransformerConfiguration.FailureBehavior;
+import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
 import software.amazon.awssdk.core.exception.SdkClientException;
 import software.amazon.awssdk.utils.Logger;
 import software.amazon.awssdk.utils.Validate;
+import software.amazon.awssdk.utils.async.SimplePublisher;
 
 /**
  * {@link AsyncResponseTransformer} that writes the data to the specified file.
@@ -59,7 +57,7 @@ public final class FileAsyncResponseTransformer<ResponseT> implements AsyncRespo
     private volatile AsynchronousFileChannel fileChannel;
     private volatile CompletableFuture<Void> cf;
     private volatile ResponseT response;
-    private final long position;
+    private long position;
     private final FileTransformerConfiguration configuration;
 
     public FileAsyncResponseTransformer(Path path) {
@@ -89,7 +87,7 @@ private static long determineFilePositionToWrite(Path path, FileTransformerConfi
         if (fileConfiguration.fileWriteOption() == WRITE_TO_POSITION) {
             return Validate.getOrDefault(fileConfiguration.position(), () -> 0L);
         }
-        return  0L;
+        return 0L;
     }
 
     private AsynchronousFileChannel createChannel(Path path) throws IOException {
@@ -134,6 +132,15 @@ public void onResponse(ResponseT response) {
         this.response = response;
     }
 
+    // to be overridden by subclasses
+    public void setOffsetPosition(long position) {
+        this.position = position;
+    }
+
+    public FileTransformerConfiguration getConfiguration() {
+        return this.configuration;
+    }
+
     @Override
     public void onStream(SdkPublisher<ByteBuffer> publisher) {
         try {
@@ -174,114 +181,4 @@ public String name() {
         return TransformerType.FILE.getName();
     }
 
-    /**
-     * {@link Subscriber} implementation that writes chunks to a file.
-     */
-    static class FileSubscriber implements Subscriber<ByteBuffer> {
-        private final AtomicLong position;
-        private final AsynchronousFileChannel fileChannel;
-        private final Path path;
-        private final CompletableFuture<Void> future;
-        private final Consumer<Throwable> onErrorMethod;
-
-        private volatile boolean writeInProgress = false;
-        private volatile boolean closeOnLastWrite = false;
-        private Subscription subscription;
-
-        FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
-                       Consumer<Throwable> onErrorMethod, long startingPosition) {
-            this.fileChannel = fileChannel;
-            this.path = path;
-            this.future = future;
-            this.onErrorMethod = onErrorMethod;
-            this.position = new AtomicLong(startingPosition);
-        }
-
-        @Override
-        public void onSubscribe(Subscription s) {
-            if (this.subscription != null) {
-                s.cancel();
-                return;
-            }
-            this.subscription = s;
-            // Request the first chunk to start producing content
-            s.request(1);
-        }
-
-        @Override
-        public void onNext(ByteBuffer byteBuffer) {
-            if (byteBuffer == null) {
-                throw new NullPointerException("Element must not be null");
-            }
-
-            performWrite(byteBuffer);
-        }
-
-        private void performWrite(ByteBuffer byteBuffer) {
-            writeInProgress = true;
-
-            fileChannel.write(byteBuffer, position.get(), byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
-                @Override
-                public void completed(Integer result, ByteBuffer attachment) {
-                    position.addAndGet(result);
-
-                    if (byteBuffer.hasRemaining()) {
-                        performWrite(byteBuffer);
-                    } else {
-                        synchronized (FileSubscriber.this) {
-                            writeInProgress = false;
-                            if (closeOnLastWrite) {
-                                close();
-                            } else {
-                                subscription.request(1);
-                            }
-                        }
-                    }
-                }
-
-                @Override
-                public void failed(Throwable exc, ByteBuffer attachment) {
-                    subscription.cancel();
-                    future.completeExceptionally(exc);
-                }
-            });
-        }
-
-        @Override
-        public void onError(Throwable t) {
-            onErrorMethod.accept(t);
-        }
-
-        @Override
-        public void onComplete() {
-            log.trace(() -> "onComplete");
-            // if write in progress, tell write to close on finish.
-            synchronized (this) {
-                if (writeInProgress) {
-                    log.trace(() -> "writeInProgress = true, not closing");
-                    closeOnLastWrite = true;
-                } else {
-                    log.trace(() -> "writeInProgress = false, closing");
-                    close();
-                }
-            }
-        }
-
-        private void close() {
-            try {
-                if (fileChannel != null) {
-                    invokeSafely(fileChannel::close);
-                }
-                log.trace(() -> "Completing File async transformer future future");
-                future.complete(null);
-            } catch (RuntimeException exception) {
-                future.completeExceptionally(exception);
-            }
-        }
-
-        @Override
-        public String toString() {
-            return getClass() + ":" + path.toString();
-        }
-    }
 }
\ No newline at end of file
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java
new file mode 100644
index 000000000000..eb4a5b21b193
--- /dev/null
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+public class FileSplittingTransformer {
+}
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java
new file mode 100644
index 000000000000..844e78549481
--- /dev/null
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
+
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousFileChannel;
+import java.nio.channels.CompletionHandler;
+import java.nio.file.Path;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import software.amazon.awssdk.utils.Logger;
+
+/**
+ * {@link Subscriber} implementation that writes chunks to a file.
+ */
+public class FileSubscriber implements Subscriber<ByteBuffer> {
+    private static final Logger log = Logger.loggerFor(FileSubscriber.class);
+    private final AtomicLong position;
+    private final AsynchronousFileChannel fileChannel;
+    private final Path path;
+    private final CompletableFuture<Void> future;
+    private final Consumer<Throwable> onErrorMethod;
+
+    private volatile boolean writeInProgress = false;
+    private volatile boolean closeOnLastWrite = false;
+    private Subscription subscription;
+
+    public FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
+                   Consumer<Throwable> onErrorMethod, long startingPosition) {
+        this.fileChannel = fileChannel;
+        this.path = path;
+        this.future = future;
+        this.onErrorMethod = onErrorMethod;
+        this.position = new AtomicLong(startingPosition);
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        if (this.subscription != null) {
+            s.cancel();
+            return;
+        }
+        this.subscription = s;
+        // Request the first chunk to start producing content
+        s.request(1);
+    }
+
+    @Override
+    public void onNext(ByteBuffer byteBuffer) {
+        if (byteBuffer == null) {
+            throw new NullPointerException("Element must not be null");
+        }
+
+        performWrite(byteBuffer);
+    }
+
+    private void performWrite(ByteBuffer byteBuffer) {
+        writeInProgress = true;
+
+        fileChannel.write(byteBuffer, position.get(), byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
+            @Override
+            public void completed(Integer result, ByteBuffer attachment) {
+                position.addAndGet(result);
+
+                if (byteBuffer.hasRemaining()) {
+                    performWrite(byteBuffer);
+                } else {
+                    synchronized (FileSubscriber.this) {
+                        writeInProgress = false;
+                        if (closeOnLastWrite) {
+                            close();
+                        } else {
+                            subscription.request(1);
+                        }
+                    }
+                }
+            }
+
+            @Override
+            public void failed(Throwable exc, ByteBuffer attachment) {
+                subscription.cancel();
+                future.completeExceptionally(exc);
+            }
+        });
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        onErrorMethod.accept(t);
+    }
+
+    @Override
+    public void onComplete() {
+        log.trace(() -> "onComplete");
+        // if write in progress, tell write to close on finish.
+        synchronized (this) {
+            if (writeInProgress) {
+                log.trace(() -> "writeInProgress = true, not closing");
+                closeOnLastWrite = true;
+            } else {
+                log.trace(() -> "writeInProgress = false, closing");
+                close();
+            }
+        }
+    }
+
+    private void close() {
+        try {
+            if (fileChannel != null) {
+                invokeSafely(fileChannel::close);
+            }
+            log.trace(() -> "Completing File async transformer future future");
+            future.complete(null);
+        } catch (RuntimeException exception) {
+            future.completeExceptionally(exception);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getClass() + ":" + path.toString();
+    }
+}
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
index 8810c3459f25..7690afaeadce 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
@@ -31,7 +31,6 @@
 import org.reactivestreams.Subscription;
 import org.reactivestreams.tck.SubscriberWhiteboxVerification;
 import org.reactivestreams.tck.TestEnvironment;
-import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer.FileSubscriber;
 
 /**
  * TCK verification test for {@link FileSubscriber}.
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
index 2cab45039d97..aaf1ee84a9ad 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
@@ -35,6 +35,7 @@
 import software.amazon.awssdk.transfer.s3.progress.TransferListener;
 import software.amazon.awssdk.transfer.s3.progress.TransferProgress;
 import software.amazon.awssdk.transfer.s3.progress.TransferProgressSnapshot;
+import software.amazon.awssdk.utils.ContentRangeParser;
 
 /**
  * An SDK-internal helper class that facilitates updating a {@link TransferProgress} and invoking {@link TransferListener}s.
diff --git a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
index 6dc7a7fc3ce8..61a686c012d7 100644
--- a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
+++ b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
@@ -17,12 +17,14 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Optional;
 import java.util.OptionalLong;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.utils.ContentRangeParser;
+import software.amazon.awssdk.utils.Pair;
 
 class ContentRangeParserTest {
 
@@ -51,4 +53,17 @@ static Stream<Arguments> argumentProvider() {
             Arguments.of("bla bla bla", OptionalLong.empty()));
     }
 
+    @ParameterizedTest
+    @MethodSource("testRange")
+    void testRange(String contentRange, Optional<Pair<Long, Long>> expected) {
+        assertThat(ContentRangeParser.range(contentRange)).isEqualTo(expected);
+    }
+
+    static Stream<Arguments> testRange() {
+        return Stream.of(
+            Arguments.of("bytes 0-9/10", Optional.of(Pair.of(0L, 9L))),
+            Arguments.of("bytes 12000000-17999999/30000000", Optional.of(Pair.of(12000000L, 17999999L)))
+        );
+    }
+
 }
\ No newline at end of file
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 2d6fadc5f505..95ff55fac84f 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -20,6 +20,7 @@
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
@@ -42,6 +43,9 @@ public <T> CompletableFuture<T> downloadObject(
         if (getObjectRequest.range() != null || getObjectRequest.partNumber() != null) {
             logSinglePartMessage(getObjectRequest);
             return s3AsyncClient.getObject(getObjectRequest, asyncResponseTransformer);
+        }
+        if (asyncResponseTransformer instanceof FileAsyncResponseTransformer) {
+
         }
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split =
             asyncResponseTransformer.split(SplittingTransformerConfiguration.builder()
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
new file mode 100644
index 000000000000..f94fdd11e067
--- /dev/null
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.internal.multipart;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletableFuture;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
+import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.utils.ContentRangeParser;
+
+public class MultipartFileAsyncResponseTransformer implements AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> {
+    private final FileAsyncResponseTransformer<GetObjectResponse> delegate;
+
+    public MultipartFileAsyncResponseTransformer(FileAsyncResponseTransformer<GetObjectResponse> delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public CompletableFuture<GetObjectResponse> prepare() {
+        return delegate.prepare();
+    }
+
+    @Override
+    public void onResponse(GetObjectResponse response) {
+        delegate.onResponse(response);
+        ContentRangeParser.range(response.contentRange())
+                          .ifPresent(pair -> delegate.setOffsetPosition(pair.left()));
+    }
+
+    @Override
+    public void onStream(SdkPublisher<ByteBuffer> publisher) {
+        delegate.onStream(publisher);
+    }
+
+    @Override
+    public void exceptionOccurred(Throwable error) {
+        delegate.exceptionOccurred(error);
+    }
+}
diff --git a/test/architecture-tests/archunit_store/4195d6e3-8849-4e5a-848d-04f810577cd3 b/test/architecture-tests/archunit_store/4195d6e3-8849-4e5a-848d-04f810577cd3
index 8c3b1f284548..c1c17fce7485 100644
--- a/test/architecture-tests/archunit_store/4195d6e3-8849-4e5a-848d-04f810577cd3
+++ b/test/architecture-tests/archunit_store/4195d6e3-8849-4e5a-848d-04f810577cd3
@@ -41,7 +41,7 @@ Method <software.amazon.awssdk.services.s3.internal.settingproviders.UseArnRegio
 Method <software.amazon.awssdk.services.sqs.internal.batchmanager.ReceiveSqsMessageHelper.clear()> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (ReceiveSqsMessageHelper.java:132)
 Method <software.amazon.awssdk.transfer.s3.internal.AsyncBufferingSubscriber.onSubscribe(org.reactivestreams.Subscription)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier)> in (AsyncBufferingSubscriber.java:67)
 Method <software.amazon.awssdk.transfer.s3.internal.PauseResumeHelper.fileModified(software.amazon.awssdk.transfer.s3.model.ResumableFileUpload, software.amazon.awssdk.services.s3.S3AsyncClient)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (PauseResumeHelper.java:59)
-Method <software.amazon.awssdk.transfer.s3.internal.progress.ContentRangeParser.totalBytes(java.lang.String)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (ContentRangeParser.java:71)
+Method <software.amazon.awssdk.utils.ContentRangeParser.totalBytes(java.lang.String)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (ContentRangeParser.java:71)
 Method <software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener.transferFailed(software.amazon.awssdk.transfer.s3.progress.TransferListener$Context$TransferFailed)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (LoggingTransferListener.java:76)
 Method <software.amazon.awssdk.utils.Logger.log(org.slf4j.event.Level, java.util.function.Supplier)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier)> in (Logger.java:205)
 Method <software.amazon.awssdk.utils.async.AddingTrailingDataSubscriber.onSubscribe(org.reactivestreams.Subscription)> calls method <software.amazon.awssdk.utils.Logger.warn(java.util.function.Supplier, java.lang.Throwable)> in (AddingTrailingDataSubscriber.java:73)
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParser.java b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
similarity index 71%
rename from services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParser.java
rename to utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
index 03e67c402a56..da65b46b594c 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParser.java
+++ b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
@@ -13,12 +13,11 @@
  * permissions and limitations under the License.
  */
 
-package software.amazon.awssdk.transfer.s3.internal.progress;
+package software.amazon.awssdk.utils;
 
+import java.util.Optional;
 import java.util.OptionalLong;
 import software.amazon.awssdk.annotations.SdkInternalApi;
-import software.amazon.awssdk.utils.Logger;
-import software.amazon.awssdk.utils.StringUtils;
 
 /**
  * Parse a Content-Range header value into a total byte count. The expected format is the following: <p></p>
@@ -72,4 +71,34 @@ public static OptionalLong totalBytes(String contentRange) {
             return OptionalLong.empty();
         }
     }
+
+    public static Optional<Pair<Long, Long>> range(String contentRange) {
+        if (StringUtils.isEmpty(contentRange)) {
+            return Optional.empty();
+        }
+
+        String trimmed = contentRange.trim();
+        if (!trimmed.startsWith("bytes ")) {
+            return Optional.empty();
+        }
+        String withoutBytes = trimmed.substring("bytes ".length());
+        int hyphen = withoutBytes.indexOf('-');
+        if (hyphen == -1) {
+            return Optional.empty();
+        }
+        String begin = withoutBytes.substring(0, hyphen);
+        int slash = withoutBytes.indexOf('/');
+        if (slash == -1) {
+            return Optional.empty();
+        }
+        String end = withoutBytes.substring(hyphen + 1, slash);
+        try {
+            long startInt = Long.parseLong(begin);
+            long endInt = Long.parseLong(end);
+            return Optional.of(Pair.of(startInt, endInt));
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+    }
+
 }
diff --git a/utils/src/main/java/software/amazon/awssdk/utils/ToString.java b/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
index 6b6fbbbe7a55..a066ae68e6e6 100644
--- a/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
+++ b/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
@@ -16,6 +16,7 @@
 package software.amazon.awssdk.utils;
 
 import java.util.Arrays;
+import java.util.concurrent.locks.ReentrantLock;
 import software.amazon.awssdk.annotations.NotThreadSafe;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
 

From 067db3049b67c8b987068b365b36b1934f622226 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 23 Jul 2025 09:17:28 -0400
Subject: [PATCH 02/41] hide cloudwatch logs for s3 regression tests

---
 .github/workflows/s3-regression-tests.yml | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/s3-regression-tests.yml b/.github/workflows/s3-regression-tests.yml
index abad4b4e675f..9b5f4fa047c9 100644
--- a/.github/workflows/s3-regression-tests.yml
+++ b/.github/workflows/s3-regression-tests.yml
@@ -51,7 +51,8 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
-          
+          hide-cloudwatch-logs: true
+
   s3-regression-tests-control-plane:
     needs: check-s3-related-changes
     if: github.repository == 'aws/aws-sdk-java-v2'
@@ -71,7 +72,8 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
-          
+          hide-cloudwatch-logs: true
+
   s3-regression-tests-upload-sync:
     needs: check-s3-related-changes
     if: github.repository == 'aws/aws-sdk-java-v2'
@@ -91,7 +93,8 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
-          
+          hide-cloudwatch-logs: true
+
   s3-regression-tests-upload-async:
     needs: check-s3-related-changes
     if: github.repository == 'aws/aws-sdk-java-v2'
@@ -111,7 +114,8 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
-          
+          hide-cloudwatch-logs: true
+
   s3-regression-tests-upload-crt:
     needs: check-s3-related-changes
     if: github.repository == 'aws/aws-sdk-java-v2'
@@ -131,7 +135,8 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
-          
+          hide-cloudwatch-logs: true
+
   s3-regression-tests-upload-multi:
     needs: check-s3-related-changes
     if: github.repository == 'aws/aws-sdk-java-v2'
@@ -151,3 +156,4 @@ jobs:
         with:
           project-name: aws-sdk-java-v2-s3-regression-tests
           env-vars-for-codebuild: REGRESSION_TEST,HAS_S3_CHANGES
+          hide-cloudwatch-logs: true
\ No newline at end of file

From 51357eed964f55250996ea856007a96c015dd1c7 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 6 Aug 2025 16:04:27 -0400
Subject: [PATCH 03/41] Multipart dowload implementation

---
 .idea/codeStyles/Project.xml                  |   1 +
 .../core/async/AsyncResponseTransformer.java  |  18 ++
 ...ltAsyncResponseTransformerSplitResult.java |  20 ++
 .../async/FileAsyncResponseTransformer.java   |  22 +-
 ...FileAsyncResponseTransformerPublisher.java | 126 +++++++++
 .../async/ThreadSafeEmittingSubscription.java |  96 +++++++
 .../progress/ContentRangeParserTest.java      |   1 +
 .../multipart/DownloadObjectHelper.java       |  29 +-
 ...MultipartFileAsyncResponseTransformer.java |  54 ----
 ...onLinearMultipartDownloaderSubscriber.java | 253 ++++++++++++++++++
 .../awssdk/utils/ContentRangeParser.java      |  12 +
 11 files changed, 569 insertions(+), 63 deletions(-)
 create mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
 create mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
 delete mode 100644 services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
 create mode 100644 services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 82511b2671f7..31e3dd29a01f 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -10,6 +10,7 @@
       </option>
       <option name="IMPORT_LAYOUT_TABLE">
         <value>
+          <package name="" withSubpackages="true" static="false" module="true" />
           <package name="" withSubpackages="true" static="true" />
           <emptyLine />
           <package name="" withSubpackages="true" static="false" />
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
index d7c872d89289..f2e5db9fb0de 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
@@ -348,6 +348,10 @@ interface SplitResult<ResponseT, ResultT>
          */
         CompletableFuture<ResultT> resultFuture();
 
+        default Boolean supportParallel() {
+            return false;
+        }
+
         static <ResponseT, ResultT> Builder<ResponseT, ResultT> builder() {
             return DefaultAsyncResponseTransformerSplitResult.builder();
         }
@@ -380,6 +384,20 @@ interface Builder<ResponseT, ResultT>
              * @return an instance of this Builder
              */
             Builder<ResponseT, ResultT> resultFuture(CompletableFuture<ResultT> future);
+
+            /**
+             * If the AsyncResponseTransformers returned by the {@link SplitResult#publisher()} support concurrent
+             * parallel streaming of multiple content body concurrently
+             * @return
+             */
+            Boolean supportsParallel();
+
+            /**
+             * Sets whether the AsyncResponseTransformers returned by the {@link SplitResult#publisher()} support concurrent
+             * parallel streaming of multiple content body concurrently
+             * @return
+             */
+            Builder<ResponseT, ResultT> supportsParallel(Boolean supportsParallel);
         }
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
index ed64b1d8eae4..f6108972ac53 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
@@ -27,12 +27,14 @@ public final class DefaultAsyncResponseTransformerSplitResult<ResponseT, ResultT
 
     private final SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
     private final CompletableFuture<ResultT> future;
+    private final Boolean supportParallel;
 
     private DefaultAsyncResponseTransformerSplitResult(Builder<ResponseT, ResultT> builder) {
         this.publisher = Validate.paramNotNull(
             builder.publisher(), "asyncResponseTransformerPublisher");
         this.future = Validate.paramNotNull(
             builder.resultFuture(), "future");
+        this.supportParallel = Validate.getOrDefault(builder.supportsParallel(), () -> false);
     }
 
     /**
@@ -52,6 +54,11 @@ public CompletableFuture<ResultT> resultFuture() {
         return this.future;
     }
 
+    @Override
+    public Boolean supportParallel() {
+        return this.supportParallel;
+    }
+
     @Override
     public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> toBuilder() {
         return new DefaultBuilder<>(this);
@@ -65,6 +72,7 @@ public static class DefaultBuilder<ResponseT, ResultT>
         implements AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> {
         private SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
         private CompletableFuture<ResultT> future;
+        private Boolean suppressParallelism;
 
         DefaultBuilder() {
         }
@@ -97,9 +105,21 @@ public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> resultFu
             return this;
         }
 
+        @Override
+        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> supportsParallel(Boolean supportsParallel) {
+            this.suppressParallelism = supportsParallel;
+            return this;
+        }
+
+        @Override
+        public Boolean supportsParallel() {
+            return suppressParallelism;
+        }
+
         @Override
         public AsyncResponseTransformer.SplitResult<ResponseT, ResultT> build() {
             return new DefaultAsyncResponseTransformerSplitResult<>(this);
         }
+
     }
 }
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index b3fc0babe791..42859512bb09 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -33,17 +33,16 @@
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
-import java.util.function.Consumer;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.FileTransformerConfiguration.FailureBehavior;
+import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
 import software.amazon.awssdk.core.exception.SdkClientException;
 import software.amazon.awssdk.utils.Logger;
 import software.amazon.awssdk.utils.Validate;
-import software.amazon.awssdk.utils.async.SimplePublisher;
 
 /**
  * {@link AsyncResponseTransformer} that writes the data to the specified file.
@@ -57,6 +56,7 @@ public final class FileAsyncResponseTransformer<ResponseT> implements AsyncRespo
     private volatile AsynchronousFileChannel fileChannel;
     private volatile CompletableFuture<Void> cf;
     private volatile ResponseT response;
+    private final long initialPosition;
     private long position;
     private final FileTransformerConfiguration configuration;
 
@@ -71,9 +71,22 @@ public FileAsyncResponseTransformer(Path path, FileTransformerConfiguration file
     private FileAsyncResponseTransformer(Path path, FileTransformerConfiguration fileTransformerConfiguration, long position) {
         this.path = path;
         this.configuration = fileTransformerConfiguration;
+        this.initialPosition = position;
         this.position = position;
     }
 
+    FileTransformerConfiguration config() {
+        return configuration;
+    }
+
+    Path path() {
+        return path;
+    }
+
+    Long initialPosition() {
+        return initialPosition;
+    }
+
     private static long determineFilePositionToWrite(Path path, FileTransformerConfiguration fileConfiguration) {
         if (fileConfiguration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
             try {
@@ -132,9 +145,8 @@ public void onResponse(ResponseT response) {
         this.response = response;
     }
 
-    // to be overridden by subclasses
-    public void setOffsetPosition(long position) {
-        this.position = position;
+    void offsetPosition(Long offset) {
+        this.position = Validate.isPositive(offset, "Offset must be positive");
     }
 
     public FileTransformerConfiguration getConfiguration() {
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
new file mode 100644
index 000000000000..99adf8f85139
--- /dev/null
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import org.reactivestreams.Subscriber;
+import software.amazon.awssdk.annotations.SdkProtectedApi;
+import software.amazon.awssdk.core.FileTransformerConfiguration;
+import software.amazon.awssdk.core.SdkResponse;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
+import software.amazon.awssdk.utils.ContentRangeParser;
+import software.amazon.awssdk.utils.Logger;
+import software.amazon.awssdk.utils.Validate;
+
+/**
+ * A publisher of {@link FileAsyncResponseTransformer} that uses the Content-Range header of a {@link SdkResponse} to write to
+ * the offset defined in the range of the Content-Range. Correspond to the {@link SplittingTransformer} for non-linear write
+ * cases. Will only work for {@link FileAsyncResponseTransformer} and will throw {@link IllegalArgumentException} if other
+ * subclasses of AsyncResponseTransformer is used with it.
+ * <p>
+ * Note: Marked as protected API because the s3 multipart logic in the s3 module needs to know about this type.
+ * @param <T>
+ */
+@SdkProtectedApi
+public class FileAsyncResponseTransformerPublisher<T extends SdkResponse> implements SdkPublisher<AsyncResponseTransformer<T, T>> {
+    private static final Logger log = Logger.loggerFor(FileAsyncResponseTransformerPublisher.class);
+
+    private final Path path;
+    private final FileTransformerConfiguration initialConfig;
+    private final long initialPosition;
+    private Subscriber subscriber;
+
+    public FileAsyncResponseTransformerPublisher(AsyncResponseTransformer<?, ?> responseTransformer) {
+        Validate.isTrue(responseTransformer instanceof FileAsyncResponseTransformer,
+                        "Only FileAsyncResponseTransformer is supported for FileAsyncResponseTransformerPublisher");
+        FileAsyncResponseTransformer<SdkResponse> transformer = (FileAsyncResponseTransformer<SdkResponse>) responseTransformer;
+        this.path = Validate.paramNotNull(transformer.path(), "path");
+        this.initialConfig = Validate.paramNotNull(transformer.config(), "fileTransformerConfiguration");
+        this.initialPosition = transformer.initialPosition();
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
+        this.subscriber = s;
+        s.onSubscribe(new ThreadSafeEmittingSubscription<>(
+            s, new AtomicLong(0), this::onCancel, new AtomicBoolean(), log, this::createTransformer));
+    }
+
+    /**
+     * Signal received from {@link Subscriber} (the one receive from the subscribe method) to stop sending
+     * IndividualFileTransformer and clean-up resources. Not necessarily an error state.
+     */
+    private void onCancel() {
+        // do nothing. We have no resources to clean and the demand is managed by ThreadSafeEmittingSubscription which will
+        // already fulfill previously signaled demand
+    }
+
+    private AsyncResponseTransformer<T, T> createTransformer() {
+        AsyncResponseTransformer<T, T> delegate = AsyncResponseTransformer.toFile(path, initialConfig);
+        return new IndividualFileTransformer((FileAsyncResponseTransformer<T>) delegate);
+    }
+
+    /**
+     * This is the AsyncResponseTransformer that will be used for each individual requests.
+     * <p>
+     * We delegate to new instances of the already existing class {@link FileAsyncResponseTransformer} to perform the
+     * individual requests. This FileAsyncResponseTransformer will write the content of the request to the file at the
+     * offset taken from the Content-Range header. As such, we don't need to manually manage the state of the
+     * AsyncResponseTransformer passed by the user, like we do for {@link SplittingTransformer}. Here, we know it is a
+     * FileAsyncResponseTransformer, so we can just ignore it, and instead rely on the individual FileAsyncResponseTransformer
+     * of every part.
+     * <p>
+     * Note on retries: since we are delegating requests to {@link FileAsyncResponseTransformer}, each request made with this
+     * transformer will retry independently based on the retry configuration of the client it is used with. We only need to
+     * verify the completion state of the future of each individually
+     */
+    class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
+        private final FileAsyncResponseTransformer<T> delegate;
+
+        IndividualFileTransformer(FileAsyncResponseTransformer<T> delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public CompletableFuture<T> prepare() {
+            return delegate.prepare(); // this future will be completed once the body has been written to file
+        }
+
+        @Override
+        public void onResponse(T response) {
+            log.info(() -> "Received response: " + response.toString());
+            ContentRangeParser.range(response.sdkHttpResponse().headers().get("Content-Range").get(0))
+                              .ifPresent(pair -> delegate.offsetPosition(initialPosition + pair.left()));
+            delegate.onResponse(response);
+        }
+
+        @Override
+        public void onStream(SdkPublisher<ByteBuffer> publisher) {
+            delegate.onStream(publisher);
+        }
+
+        @Override
+        public void exceptionOccurred(Throwable error) {
+            delegate.exceptionOccurred(error);
+        }
+    }
+
+}
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
new file mode 100644
index 000000000000..c47bc33b2af1
--- /dev/null
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import software.amazon.awssdk.utils.Logger;
+
+public class ThreadSafeEmittingSubscription<T> implements Subscription {
+
+    private final AtomicBoolean emitting = new AtomicBoolean(false);
+    private final Subscriber<T> downstreamSubscriber;
+    private final AtomicLong outstandingDemand;
+    private final Runnable onCancel;
+    private final AtomicBoolean isCancelled;
+    private final Supplier<T> supplier;
+    private final Logger log;
+
+    public ThreadSafeEmittingSubscription(Subscriber<T> downstreamSubscriber, AtomicLong outstandingDemand,
+                                          Runnable onCancel, AtomicBoolean isCancelled, Logger log, Supplier<T> supplier) {
+        this.downstreamSubscriber = downstreamSubscriber;
+        this.outstandingDemand = outstandingDemand;
+        this.onCancel = onCancel;
+        this.isCancelled = isCancelled;
+        this.log = log;
+        this.supplier = supplier;
+    }
+
+    @Override
+    public void request(long n) {
+        if (n <= 0) {
+            downstreamSubscriber.onError(new IllegalArgumentException("Amount requested must be positive"));
+            return;
+        }
+        long newDemand = outstandingDemand.updateAndGet(current -> {
+            if (Long.MAX_VALUE - current < n) {
+                return Long.MAX_VALUE;
+            }
+            return current + n;
+        });
+        log.trace(() -> String.format("new outstanding demand: %s", newDemand));
+        emit();
+    }
+
+    @Override
+    public void cancel() {
+        onCancel.run();
+    }
+
+    private void emit() {
+        do {
+            if (!emitting.compareAndSet(false, true)) {
+                return;
+            }
+            try {
+                if (doEmit()) {
+                    return;
+                }
+            } finally {
+                emitting.compareAndSet(true, false);
+            }
+        } while (outstandingDemand.get() > 0);
+    }
+
+    private boolean doEmit() {
+        long demand = outstandingDemand.get();
+
+        while (demand > 0) {
+            if (isCancelled.get()) {
+                return true;
+            }
+            if (outstandingDemand.get() > 0) {
+                demand = outstandingDemand.decrementAndGet();
+                downstreamSubscriber.onNext(supplier.get());
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
index 61a686c012d7..b432d93996a7 100644
--- a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
+++ b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
@@ -62,6 +62,7 @@ void testRange(String contentRange, Optional<Pair<Long, Long>> expected) {
     static Stream<Arguments> testRange() {
         return Stream.of(
             Arguments.of("bytes 0-9/10", Optional.of(Pair.of(0L, 9L))),
+            Arguments.of("bytes */10", Optional.empty()),
             Arguments.of("bytes 12000000-17999999/30000000", Optional.of(Pair.of(12000000L, 17999999L)))
         );
     }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 95ff55fac84f..91f668f1be6e 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -20,7 +20,7 @@
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
-import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer;
+import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformerPublisher;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
@@ -43,14 +43,35 @@ public <T> CompletableFuture<T> downloadObject(
         if (getObjectRequest.range() != null || getObjectRequest.partNumber() != null) {
             logSinglePartMessage(getObjectRequest);
             return s3AsyncClient.getObject(getObjectRequest, asyncResponseTransformer);
-        }
-        if (asyncResponseTransformer instanceof FileAsyncResponseTransformer) {
-
         }
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split =
             asyncResponseTransformer.split(SplittingTransformerConfiguration.builder()
                                                                             .bufferSizeInBytes(bufferSizeInBytes)
                                                                             .build());
+        if (!split.supportParallel()) {
+            return downloadPartsLinear(getObjectRequest, split);
+        }
+
+        // The publisher of AsyncResponseTransformer needs to know about s3 GetObjectResponse to write to the correct file offset.
+        // The default publisher in the SplitResult may not be able to do so, so we need to create a new one that knows about s3
+        FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
+            new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
+        return downloadPartsNonLinear(getObjectRequest, publisher, split);
+
+    }
+
+    private <T> CompletableFuture<T> downloadPartsNonLinear(GetObjectRequest getObjectRequest,
+                                                            FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher,
+                                                            AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
+        // TODO pause & resume
+        NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
+            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture());
+        publisher.subscribe(subscriber);
+        return split.resultFuture();
+    }
+
+    private <T> CompletableFuture<T> downloadPartsLinear(GetObjectRequest getObjectRequest,
+                                                         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
         MultipartDownloaderSubscriber subscriber = subscriber(getObjectRequest);
         split.publisher().subscribe(subscriber);
         return split.resultFuture();
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
deleted file mode 100644
index f94fdd11e067..000000000000
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartFileAsyncResponseTransformer.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
- *
- *  http://aws.amazon.com/apache2.0
- *
- * or in the "license" file accompanying this file. This file is distributed
- * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package software.amazon.awssdk.services.s3.internal.multipart;
-
-import java.nio.ByteBuffer;
-import java.util.concurrent.CompletableFuture;
-import software.amazon.awssdk.core.async.AsyncResponseTransformer;
-import software.amazon.awssdk.core.async.SdkPublisher;
-import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer;
-import software.amazon.awssdk.services.s3.model.GetObjectResponse;
-import software.amazon.awssdk.utils.ContentRangeParser;
-
-public class MultipartFileAsyncResponseTransformer implements AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> {
-    private final FileAsyncResponseTransformer<GetObjectResponse> delegate;
-
-    public MultipartFileAsyncResponseTransformer(FileAsyncResponseTransformer<GetObjectResponse> delegate) {
-        this.delegate = delegate;
-    }
-
-    @Override
-    public CompletableFuture<GetObjectResponse> prepare() {
-        return delegate.prepare();
-    }
-
-    @Override
-    public void onResponse(GetObjectResponse response) {
-        delegate.onResponse(response);
-        ContentRangeParser.range(response.contentRange())
-                          .ifPresent(pair -> delegate.setOffsetPosition(pair.left()));
-    }
-
-    @Override
-    public void onStream(SdkPublisher<ByteBuffer> publisher) {
-        delegate.onStream(publisher);
-    }
-
-    @Override
-    public void exceptionOccurred(Throwable error) {
-        delegate.exceptionOccurred(error);
-    }
-}
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
new file mode 100644
index 000000000000..e1b76f79795a
--- /dev/null
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.internal.multipart;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.utils.CompletableFutureUtils;
+import software.amazon.awssdk.utils.Logger;
+
+public class NonLinearMultipartDownloaderSubscriber
+    implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
+    private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
+
+    /**
+     * The s3 client used to make the individual part requests
+     */
+    private final S3AsyncClient s3;
+
+    /**
+     * The GetObjectRequest that was provided when calling s3.getObject(...). It is copied for each individual request, and the
+     * copy has the partNumber field updated as more parts are downloaded.
+     */
+    private final GetObjectRequest getObjectRequest;
+
+    /**
+     * The total number of completed parts. A part is considered complete once the completable future associated with its request
+     * completes successfully.
+     */
+    private final AtomicInteger completedParts = new AtomicInteger();
+
+    /**
+     * Queue of all remaining parts in ascending order. i.e. 4, 5, 6, 8, 11
+     */
+    private final Queue<Integer> allRemainingParts = new ArrayDeque<>();
+
+    /**
+     * The future returned to the user when calling
+     * {@link S3AsyncClient#getObject(GetObjectRequest, AsyncResponseTransformer) getObject}. This will be completed once the last
+     * part finishes. Contrary to the linear code path, the future returned to the user is handled here so that we can complete it
+     * once the last part writting to the file is completed.
+     */
+    private final CompletableFuture<GetObjectResponse> resultFuture;
+
+    /**
+     * The {@link GetObjectResponse} to be returned in the completed future to the user. It corresponds to the first part
+     */
+    private GetObjectResponse getObjectResponse;
+
+    /**
+     * The subscription received from the publisher this subscriber subscribes to.
+     */
+    private Subscription subscription;
+
+    /**
+     * This value indicates the total number of parts of the object to get. If null, it means we don't know the total amount of
+     * parts, either because we haven't received a response from s3 yet to set it, or the object to get is not multipart.
+     */
+    private volatile Integer totalParts;
+
+
+    /**
+     * The etag of the object being downloaded.
+     */
+    private volatile String eTag;
+
+    /**
+     * The amount of in flights requests
+     */
+    private final AtomicInteger inFlights = new AtomicInteger();
+
+    private final Object lock = new Object();
+
+    public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
+                                                  CompletableFuture<GetObjectResponse> resultFuture) {
+        this.s3 = s3;
+        this.getObjectRequest = getObjectRequest;
+        this.resultFuture = resultFuture;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        if (this.subscription != null) {
+            s.cancel();
+            return;
+        }
+        this.subscription = s;
+        this.subscription.request(1);
+    }
+
+    @Override
+    public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+        if (asyncResponseTransformer == null) {
+            subscription.cancel();
+            throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
+        }
+
+        // Handle first request case
+        if (completedParts.get() == 0) {
+            synchronized (lock) {
+                if (sendFirstRequest(asyncResponseTransformer)) {
+                    // we don't know yet if we can request more. We can only request more if the object requested has multiple
+                    // parts, and we can only know that by looking at the 'totalParts' field of the response.
+                    // So we return for now without requesting more, and only request more when the first request completes.
+                    // Note that this may be long, since calling GetObject with a FileAsyncResponseTransformer returns a future
+                    // that is completed only when the body has been written to the file. This means the subsequent requests
+                    // can only be sent after the first part is fully written to the file.
+                    return;
+                }
+
+            }
+        }
+        sendNextRequest(asyncResponseTransformer);
+        requestMoreIfNeeded();
+    }
+
+    private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+        if (inFlights.get() + completedParts.get() >= totalParts) {
+            // all requests are already being processed
+            return;
+        }
+
+        int partToGet = nextPart();
+        GetObjectRequest request = nextRequest(partToGet);
+        inFlights.incrementAndGet();
+        log.info(() -> "============== Sending next request for part: '" + partToGet + "' ==============");
+        CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
+        response.whenComplete((res, e) -> {
+            log.info(() -> "============== Completed part: '" + partToGet + "' ==============");
+            inFlights.decrementAndGet();
+            if (e != null) {
+                resultFuture.completeExceptionally(e);
+                return;
+            }
+            completedParts.incrementAndGet();
+            if (completedParts.get() == totalParts) {
+                subscription.cancel();
+                resultFuture.complete(getObjectResponse);
+            }
+        });
+    }
+
+    // returns true if we actually sent the request
+    private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+        // we could have completed the first request while waiting on synchronized block, check again
+        if (completedParts.get() != 0) {
+            // another thread sent the first request already
+            return false;
+        }
+        log.info(() -> "============== SENDING FIRST REQUEST ==============");
+        GetObjectRequest request = nextRequest(1);
+        inFlights.incrementAndGet();
+        CompletableFuture<GetObjectResponse> responseFuture = s3.getObject(request, asyncResponseTransformer);
+
+        // Propagate cancellation from user
+        CompletableFutureUtils.forwardExceptionTo(resultFuture, responseFuture);
+
+        responseFuture.whenComplete((res, e) -> {
+            inFlights.decrementAndGet();
+            if (e != null) {
+                // note on retries: When this future completed exceptionally, it means we did all retries and still failed
+                // we need to report back the failure to the user.
+                resultFuture.completeExceptionally(e);
+                return;
+            }
+            completedParts.incrementAndGet();
+            Integer partCount = res.partsCount();
+            eTag = res.eTag();
+            if (partCount != null && totalParts == null) {
+                log.info(() -> String.format("Total amount of parts of the object to download: %d", partCount));
+                // MultipartDownloadUtils.multipartDownloadResumeContext(getObjectRequest)
+                //                       .ifPresent(ctx -> ctx.totalParts(partCount));
+                totalParts = partCount;
+            }
+
+            if (totalParts == null || totalParts == 1) {
+                // Single part object, skip multipart and complete everything now
+                log.info(() -> "Single Part object detected, skipping multipart download");
+                subscription.cancel();
+                resultFuture.complete(res);
+                return;
+            }
+            // it is a multipart object
+            log.info(() -> "Multipart object detected, performing multipart download");
+            // part 1 already completed, so skip it
+            for (int i = 2; i <= totalParts; i++) {
+                allRemainingParts.add(i);
+            }
+            getObjectResponse = res;
+            subscription.request(1);
+        });
+        return true;
+    }
+
+    private void requestMoreIfNeeded() {
+        if (allPartsCompletedOrInFlights()) {
+            return;
+        }
+        subscription.request(1);
+    }
+
+    private Integer nextPart() {
+        synchronized (allRemainingParts) {
+            return allRemainingParts.poll();
+        }
+    }
+
+    private boolean allPartsCompletedOrInFlights() {
+        return inFlights.get() + completedParts.get() >= totalParts;
+    }
+
+    @Override
+    public void onError(Throwable t) {
+
+    }
+
+    @Override
+    public void onComplete() {
+
+    }
+
+    private GetObjectRequest nextRequest(int nextPartToGet) {
+        return getObjectRequest.copy(req -> {
+            req.partNumber(nextPartToGet);
+            if (eTag != null) {
+                req.ifMatch(eTag);
+            }
+        });
+    }
+
+}
diff --git a/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
index da65b46b594c..f21dd1702b25 100644
--- a/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
+++ b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
@@ -72,6 +72,15 @@ public static OptionalLong totalBytes(String contentRange) {
         }
     }
 
+    /**
+     * Parse the Content-Range to extract the byte range from the content. Only supports the {@code bytes} unit, any
+     * other unit will result in an empty OptionalLong. If byte range in unknown, which is represented by a {@code *} symbol
+     * in the header value, an empty OptionalLong will be returned.
+     *
+     * @param contentRange the value of the Content-Range header to be parsed.
+     * @return The total number of bytes in the content range or an empty optional if the contentRange is null, empty or if the
+     * total length is not a valid long.
+     */
     public static Optional<Pair<Long, Long>> range(String contentRange) {
         if (StringUtils.isEmpty(contentRange)) {
             return Optional.empty();
@@ -82,6 +91,9 @@ public static Optional<Pair<Long, Long>> range(String contentRange) {
             return Optional.empty();
         }
         String withoutBytes = trimmed.substring("bytes ".length());
+        if (withoutBytes.startsWith("*")) {
+            return Optional.empty();
+        }
         int hyphen = withoutBytes.indexOf('-');
         if (hyphen == -1) {
             return Optional.empty();

From a9d25ec042362da59def1c731d16de1764250468 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Mon, 11 Aug 2025 12:37:51 -0400
Subject: [PATCH 04/41] Multipart dowload implementation

---
 .../multipart/NonLinearMultipartDownloaderSubscriber.java   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index e1b76f79795a..8ab7ccb7004d 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -209,16 +209,16 @@ private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, Get
                 allRemainingParts.add(i);
             }
             getObjectResponse = res;
+            // request the next part, which will start the whole multipart dl in parallel
             subscription.request(1);
         });
         return true;
     }
 
     private void requestMoreIfNeeded() {
-        if (allPartsCompletedOrInFlights()) {
-            return;
+        if (!allPartsCompletedOrInFlights()) {
+            subscription.request(1);
         }
-        subscription.request(1);
     }
 
     private Integer nextPart() {

From 7c82e2bb5ab768fa192385564341da8da395dc99 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 19 Aug 2025 15:34:39 -0400
Subject: [PATCH 05/41] Update non-linear download logic

---
 .../async/FileAsyncResponseTransformer.java   |  8 ++++++-
 ...FileAsyncResponseTransformerPublisher.java | 24 ++++++++++++++++---
 .../multipart/DownloadObjectHelper.java       | 14 ++++++-----
 ...onLinearMultipartDownloaderSubscriber.java | 22 +++++++++++++----
 4 files changed, 53 insertions(+), 15 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 42859512bb09..54af27928f71 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -146,7 +146,7 @@ public void onResponse(ResponseT response) {
     }
 
     void offsetPosition(Long offset) {
-        this.position = Validate.isPositive(offset, "Offset must be positive");
+        this.position = Validate.isNotNegative(offset, "Offset must be positive");
     }
 
     public FileTransformerConfiguration getConfiguration() {
@@ -193,4 +193,10 @@ public String name() {
         return TransformerType.FILE.getName();
     }
 
+    @Override
+    public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
+        return AsyncResponseTransformer.super
+            .split(splitConfig)
+            .copy(res -> res.supportsParallel(true));
+    }
 }
\ No newline at end of file
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 99adf8f85139..cf2d238e31e6 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -17,6 +17,7 @@
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
@@ -26,6 +27,7 @@
 import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
+import software.amazon.awssdk.utils.CollectionUtils;
 import software.amazon.awssdk.utils.ContentRangeParser;
 import software.amazon.awssdk.utils.Logger;
 import software.amazon.awssdk.utils.Validate;
@@ -47,6 +49,7 @@ public class FileAsyncResponseTransformerPublisher<T extends SdkResponse> implem
     private final FileTransformerConfiguration initialConfig;
     private final long initialPosition;
     private Subscriber subscriber;
+    private AtomicLong transformerSent;
 
     public FileAsyncResponseTransformerPublisher(AsyncResponseTransformer<?, ?> responseTransformer) {
         Validate.isTrue(responseTransformer instanceof FileAsyncResponseTransformer,
@@ -55,6 +58,7 @@ public FileAsyncResponseTransformerPublisher(AsyncResponseTransformer<?, ?> resp
         this.path = Validate.paramNotNull(transformer.path(), "path");
         this.initialConfig = Validate.paramNotNull(transformer.config(), "fileTransformerConfiguration");
         this.initialPosition = transformer.initialPosition();
+        transformerSent = new AtomicLong();
     }
 
     @Override
@@ -74,7 +78,15 @@ private void onCancel() {
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
-        AsyncResponseTransformer<T, T> delegate = AsyncResponseTransformer.toFile(path, initialConfig);
+        AsyncResponseTransformer<T, T> delegate;
+        // todo deal with APPEND mode
+        if (transformerSent.get() == 0) {
+            delegate = AsyncResponseTransformer.toFile(path, initialConfig);
+        } else {
+            delegate = AsyncResponseTransformer.toFile(path, initialConfig.copy(
+                c -> c.fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)));
+        }
+        transformerSent.incrementAndGet();
         return new IndividualFileTransformer((FileAsyncResponseTransformer<T>) delegate);
     }
 
@@ -107,8 +119,14 @@ public CompletableFuture<T> prepare() {
         @Override
         public void onResponse(T response) {
             log.info(() -> "Received response: " + response.toString());
-            ContentRangeParser.range(response.sdkHttpResponse().headers().get("Content-Range").get(0))
-                              .ifPresent(pair -> delegate.offsetPosition(initialPosition + pair.left()));
+            // todo: move to s3 package to use GetObjectResponse?
+            List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
+            if (!CollectionUtils.isNullOrEmpty(contentRangeList)) {
+                String contentRange = contentRangeList.get(0);
+                log.info(() -> "Setting offset to " + contentRange);
+                ContentRangeParser.range(contentRange)
+                                  .ifPresent(pair -> delegate.offsetPosition(initialPosition + pair.left()));
+            }
             delegate.onResponse(response);
         }
 
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 91f668f1be6e..9a5ca05c1236 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -54,16 +54,18 @@ public <T> CompletableFuture<T> downloadObject(
 
         // The publisher of AsyncResponseTransformer needs to know about s3 GetObjectResponse to write to the correct file offset.
         // The default publisher in the SplitResult may not be able to do so, so we need to create a new one that knows about s3
-        FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
-        return downloadPartsNonLinear(getObjectRequest, publisher, split);
+        log.info(() -> "================= USING downloadPartsNonLinear ==================");
+        return downloadPartsNonLinear(getObjectRequest, asyncResponseTransformer, split);
 
     }
 
-    private <T> CompletableFuture<T> downloadPartsNonLinear(GetObjectRequest getObjectRequest,
-                                                            FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher,
-                                                            AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
+    private <T> CompletableFuture<T> downloadPartsNonLinear(
+        GetObjectRequest getObjectRequest,
+        AsyncResponseTransformer<GetObjectResponse, T> asyncResponseTransformer,
+        AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
         // TODO pause & resume
+        FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
+            new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
             s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture());
         publisher.subscribe(subscriber);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 8ab7ccb7004d..5dc068172786 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -17,12 +17,11 @@
 
 import java.util.ArrayDeque;
 import java.util.Queue;
-import java.util.SortedSet;
-import java.util.TreeSet;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
+import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
@@ -30,9 +29,11 @@
 import software.amazon.awssdk.utils.CompletableFutureUtils;
 import software.amazon.awssdk.utils.Logger;
 
+@SdkInternalApi
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
     private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
+    private static final int MAX_IN_FLIGHT = 8;
 
     /**
      * The s3 client used to make the individual part requests
@@ -95,6 +96,7 @@ public class NonLinearMultipartDownloaderSubscriber
 
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture) {
+        System.out.println("[DEBUG] NonLinearMultipartDownloaderSubscriber constructor called");
         this.s3 = s3;
         this.getObjectRequest = getObjectRequest;
         this.resultFuture = resultFuture;
@@ -112,6 +114,7 @@ public void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+        log.info(() -> "onNext");
         if (asyncResponseTransformer == null) {
             subscription.cancel();
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
@@ -158,17 +161,25 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             if (completedParts.get() == totalParts) {
                 subscription.cancel();
                 resultFuture.complete(getObjectResponse);
+            } else {
+                requestMoreIfNeeded();
             }
         });
     }
 
-    // returns true if we actually sent the request
+    // returns true if the first request was sent, either by this call the this method, or previously
     private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         // we could have completed the first request while waiting on synchronized block, check again
         if (completedParts.get() != 0) {
-            // another thread sent the first request already
+            // another thread sent the first request already and it is completed.
+            // We know at this point if it is multipart or not
             return false;
         }
+        if (inFlights.get() > 0) {
+            // We might not know if it is multipart or not
+            // first request is already in flight, wait for it to finish before requesting more
+            return true;
+        }
         log.info(() -> "============== SENDING FIRST REQUEST ==============");
         GetObjectRequest request = nextRequest(1);
         inFlights.incrementAndGet();
@@ -216,7 +227,8 @@ private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, Get
     }
 
     private void requestMoreIfNeeded() {
-        if (!allPartsCompletedOrInFlights()) {
+        if (!allPartsCompletedOrInFlights() && inFlights.get() < MAX_IN_FLIGHT) {
+            log.info(() -> "requesting next part");
             subscription.request(1);
         }
     }

From 978f5533476a2a76158b393009ea221a80009e2b Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 20 Aug 2025 10:41:29 -0400
Subject: [PATCH 06/41] request max-in-flight at first request

---
 ...onLinearMultipartDownloaderSubscriber.java | 85 ++++++++++++-------
 1 file changed, 52 insertions(+), 33 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 5dc068172786..c8476d5bbcf8 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -19,6 +19,7 @@
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import software.amazon.awssdk.annotations.SdkInternalApi;
@@ -92,7 +93,9 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicInteger inFlights = new AtomicInteger();
 
-    private final Object lock = new Object();
+    private final ReentrantLock firstPartLock = new ReentrantLock();
+    private final Queue<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> pendingTransformers = new ArrayDeque<>();
+    private volatile boolean firstRequestSent = false;
 
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture) {
@@ -109,7 +112,7 @@ public void onSubscribe(Subscription s) {
             return;
         }
         this.subscription = s;
-        this.subscription.request(1);
+        this.subscription.request(MAX_IN_FLIGHT);
     }
 
     @Override
@@ -120,28 +123,42 @@ public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
         }
 
-        // Handle first request case
+        if (handleFirstRequest(asyncResponseTransformer)) {
+            return;
+        }
+
+        sendNextRequest(asyncResponseTransformer);
+        requestMoreIfNeeded();
+    }
+
+    // Handle first request.
+    // We need to wait for the first request to finish so we know if it is aa multipart object or not.
+    // While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
+    private boolean handleFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (completedParts.get() == 0) {
-            synchronized (lock) {
-                if (sendFirstRequest(asyncResponseTransformer)) {
-                    // we don't know yet if we can request more. We can only request more if the object requested has multiple
-                    // parts, and we can only know that by looking at the 'totalParts' field of the response.
-                    // So we return for now without requesting more, and only request more when the first request completes.
-                    // Note that this may be long, since calling GetObject with a FileAsyncResponseTransformer returns a future
-                    // that is completed only when the body has been written to the file. This means the subsequent requests
-                    // can only be sent after the first part is fully written to the file.
-                    return;
+            firstPartLock.lock();
+            try {
+                if (!firstRequestSent) {
+                    sendFirstRequest(asyncResponseTransformer);
+                    firstRequestSent = true;
+                    return true;
                 }
 
+                // First request already sent, queue this transformer
+                synchronized (pendingTransformers) {
+                    pendingTransformers.offer(asyncResponseTransformer);
+                }
+            } finally {
+                firstPartLock.unlock();
             }
+            return true;
         }
-        sendNextRequest(asyncResponseTransformer);
-        requestMoreIfNeeded();
+        return false;
     }
 
     private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+        // guardrails: we shouldn't send more requests than
         if (inFlights.get() + completedParts.get() >= totalParts) {
-            // all requests are already being processed
             return;
         }
 
@@ -167,19 +184,8 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         });
     }
 
-    // returns true if the first request was sent, either by this call the this method, or previously
-    private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        // we could have completed the first request while waiting on synchronized block, check again
-        if (completedParts.get() != 0) {
-            // another thread sent the first request already and it is completed.
-            // We know at this point if it is multipart or not
-            return false;
-        }
-        if (inFlights.get() > 0) {
-            // We might not know if it is multipart or not
-            // first request is already in flight, wait for it to finish before requesting more
-            return true;
-        }
+    // returns true if the first request was sent and is still in flight
+    private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         log.info(() -> "============== SENDING FIRST REQUEST ==============");
         GetObjectRequest request = nextRequest(1);
         inFlights.incrementAndGet();
@@ -191,7 +197,7 @@ private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, Get
         responseFuture.whenComplete((res, e) -> {
             inFlights.decrementAndGet();
             if (e != null) {
-                // note on retries: When this future completed exceptionally, it means we did all retries and still failed
+                // Note on retries: When this future completed exceptionally, it means we did all retries and still failed
                 // we need to report back the failure to the user.
                 resultFuture.completeExceptionally(e);
                 return;
@@ -206,24 +212,37 @@ private boolean sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, Get
                 totalParts = partCount;
             }
 
+            // it is a multipart object?
             if (totalParts == null || totalParts == 1) {
-                // Single part object, skip multipart and complete everything now
+                // Single part object detected, skip multipart and complete everything now
                 log.info(() -> "Single Part object detected, skipping multipart download");
                 subscription.cancel();
                 resultFuture.complete(res);
                 return;
             }
-            // it is a multipart object
+
             log.info(() -> "Multipart object detected, performing multipart download");
             // part 1 already completed, so skip it
             for (int i = 2; i <= totalParts; i++) {
                 allRemainingParts.add(i);
             }
             getObjectResponse = res;
-            // request the next part, which will start the whole multipart dl in parallel
+            
+            // Process pending transformers
+            processPendingTransformers();
+            
             subscription.request(1);
         });
-        return true;
+    }
+
+    private void processPendingTransformers() {
+        synchronized (pendingTransformers) {
+            AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer =  pendingTransformers.poll();
+            while (transformer != null) {
+                sendNextRequest(transformer);
+                transformer = pendingTransformers.poll();
+            }
+        }
     }
 
     private void requestMoreIfNeeded() {

From 3e29b8cf57d348bf7a591725726b15bf0e0ed4d5 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 21 Aug 2025 16:28:33 -0400
Subject: [PATCH 07/41] remove stateful calls to FileAsyncResponseTransformer
 by creating it in the onResponse callback. Keep track of all inflight
 requests.

---
 .../core/async/AsyncResponseTransformer.java  |  10 +-
 ...ltAsyncResponseTransformerSplitResult.java |  22 ++--
 .../async/FileAsyncResponseTransformer.java   |  20 ++--
 ...FileAsyncResponseTransformerPublisher.java | 106 +++++++++++------
 .../async/ThreadSafeEmittingSubscription.java |   2 +
 .../multipart/DownloadObjectHelper.java       |  23 ++--
 ...onLinearMultipartDownloaderSubscriber.java | 110 +++++++++++-------
 .../multipart/MultipartDownloadTestUtil.java  |  11 ++
 8 files changed, 186 insertions(+), 118 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
index f2e5db9fb0de..033542b929d7 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
@@ -348,7 +348,11 @@ interface SplitResult<ResponseT, ResultT>
          */
         CompletableFuture<ResultT> resultFuture();
 
-        default Boolean supportParallel() {
+        /**
+         * TODO javadoc
+         * @return
+         */
+        default Boolean supportsNonSerial() {
             return false;
         }
 
@@ -390,14 +394,14 @@ interface Builder<ResponseT, ResultT>
              * parallel streaming of multiple content body concurrently
              * @return
              */
-            Boolean supportsParallel();
+            Boolean supportsNonSerial();
 
             /**
              * Sets whether the AsyncResponseTransformers returned by the {@link SplitResult#publisher()} support concurrent
              * parallel streaming of multiple content body concurrently
              * @return
              */
-            Builder<ResponseT, ResultT> supportsParallel(Boolean supportsParallel);
+            Builder<ResponseT, ResultT> supportsNonSerial(Boolean supportsParallel);
         }
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
index f6108972ac53..ec9f56e892ec 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
@@ -27,14 +27,14 @@ public final class DefaultAsyncResponseTransformerSplitResult<ResponseT, ResultT
 
     private final SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
     private final CompletableFuture<ResultT> future;
-    private final Boolean supportParallel;
+    private final Boolean supportsNonSerial;
 
     private DefaultAsyncResponseTransformerSplitResult(Builder<ResponseT, ResultT> builder) {
         this.publisher = Validate.paramNotNull(
             builder.publisher(), "asyncResponseTransformerPublisher");
         this.future = Validate.paramNotNull(
             builder.resultFuture(), "future");
-        this.supportParallel = Validate.getOrDefault(builder.supportsParallel(), () -> false);
+        this.supportsNonSerial = Validate.getOrDefault(builder.supportsNonSerial(), () -> false);
     }
 
     /**
@@ -55,8 +55,8 @@ public CompletableFuture<ResultT> resultFuture() {
     }
 
     @Override
-    public Boolean supportParallel() {
-        return this.supportParallel;
+    public Boolean supportsNonSerial() {
+        return this.supportsNonSerial;
     }
 
     @Override
@@ -100,20 +100,22 @@ public CompletableFuture<ResultT> resultFuture() {
         }
 
         @Override
-        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> resultFuture(CompletableFuture<ResultT> future) {
+        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> resultFuture(
+            CompletableFuture<ResultT> future) {
             this.future = future;
             return this;
         }
 
         @Override
-        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> supportsParallel(Boolean supportsParallel) {
-            this.suppressParallelism = supportsParallel;
-            return this;
+        public Boolean supportsNonSerial() {
+            return suppressParallelism;
         }
 
         @Override
-        public Boolean supportsParallel() {
-            return suppressParallelism;
+        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> supportsNonSerial(
+            Boolean supportsParallel) {
+            this.suppressParallelism = supportsParallel;
+            return this;
         }
 
         @Override
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 54af27928f71..17c123d663d5 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -56,7 +56,6 @@ public final class FileAsyncResponseTransformer<ResponseT> implements AsyncRespo
     private volatile AsynchronousFileChannel fileChannel;
     private volatile CompletableFuture<Void> cf;
     private volatile ResponseT response;
-    private final long initialPosition;
     private long position;
     private final FileTransformerConfiguration configuration;
 
@@ -71,20 +70,19 @@ public FileAsyncResponseTransformer(Path path, FileTransformerConfiguration file
     private FileAsyncResponseTransformer(Path path, FileTransformerConfiguration fileTransformerConfiguration, long position) {
         this.path = path;
         this.configuration = fileTransformerConfiguration;
-        this.initialPosition = position;
         this.position = position;
     }
 
-    FileTransformerConfiguration config() {
-        return configuration;
+    public FileTransformerConfiguration config() {
+        return configuration.toBuilder().build();
     }
 
-    Path path() {
+    public Path path() {
         return path;
     }
 
-    Long initialPosition() {
-        return initialPosition;
+    public Long initialPosition() {
+        return position;
     }
 
     private static long determineFilePositionToWrite(Path path, FileTransformerConfiguration fileConfiguration) {
@@ -145,10 +143,6 @@ public void onResponse(ResponseT response) {
         this.response = response;
     }
 
-    void offsetPosition(Long offset) {
-        this.position = Validate.isNotNegative(offset, "Offset must be positive");
-    }
-
     public FileTransformerConfiguration getConfiguration() {
         return this.configuration;
     }
@@ -197,6 +191,8 @@ public String name() {
     public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
         return AsyncResponseTransformer.super
             .split(splitConfig)
-            .copy(res -> res.supportsParallel(true));
+            .copy(
+                res -> res.supportsNonSerial(true)
+                          .publisher(new FileAsyncResponseTransformerPublisher(this)));
     }
 }
\ No newline at end of file
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index cf2d238e31e6..375df818f5e5 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -18,31 +18,38 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import org.reactivestreams.Subscriber;
+import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
 import software.amazon.awssdk.utils.CollectionUtils;
+import software.amazon.awssdk.utils.CompletableFutureUtils;
 import software.amazon.awssdk.utils.ContentRangeParser;
 import software.amazon.awssdk.utils.Logger;
+import software.amazon.awssdk.utils.Pair;
+import software.amazon.awssdk.utils.StringUtils;
 import software.amazon.awssdk.utils.Validate;
 
 /**
- * A publisher of {@link FileAsyncResponseTransformer} that uses the Content-Range header of a {@link SdkResponse} to write to
- * the offset defined in the range of the Content-Range. Correspond to the {@link SplittingTransformer} for non-linear write
- * cases. Will only work for {@link FileAsyncResponseTransformer} and will throw {@link IllegalArgumentException} if other
- * subclasses of AsyncResponseTransformer is used with it.
+ * A publisher of {@link FileAsyncResponseTransformer} that uses the Content-Range header of a {@link SdkResponse} to write to the
+ * offset defined in the range of the Content-Range. Correspond to the {@link SplittingTransformer} for non-linear write cases.
+ * Will only work for {@link FileAsyncResponseTransformer} and will throw {@link IllegalArgumentException} if other subclasses of
+ * AsyncResponseTransformer is used with it.
  * <p>
  * Note: Marked as protected API because the s3 multipart logic in the s3 module needs to know about this type.
+ *
  * @param <T>
  */
-@SdkProtectedApi
-public class FileAsyncResponseTransformerPublisher<T extends SdkResponse> implements SdkPublisher<AsyncResponseTransformer<T, T>> {
+@SdkInternalApi
+public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
+    implements SdkPublisher<AsyncResponseTransformer<T, T>> {
     private static final Logger log = Logger.loggerFor(FileAsyncResponseTransformerPublisher.class);
 
     private final Path path;
@@ -78,66 +85,89 @@ private void onCancel() {
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
-        AsyncResponseTransformer<T, T> delegate;
-        // todo deal with APPEND mode
-        if (transformerSent.get() == 0) {
-            delegate = AsyncResponseTransformer.toFile(path, initialConfig);
-        } else {
-            delegate = AsyncResponseTransformer.toFile(path, initialConfig.copy(
-                c -> c.fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)));
-        }
-        transformerSent.incrementAndGet();
-        return new IndividualFileTransformer((FileAsyncResponseTransformer<T>) delegate);
+        return new IndividualFileTransformer();
     }
 
     /**
      * This is the AsyncResponseTransformer that will be used for each individual requests.
      * <p>
-     * We delegate to new instances of the already existing class {@link FileAsyncResponseTransformer} to perform the
-     * individual requests. This FileAsyncResponseTransformer will write the content of the request to the file at the
-     * offset taken from the Content-Range header. As such, we don't need to manually manage the state of the
+     * We delegate to new instances of the already existing class {@link FileAsyncResponseTransformer} to perform the individual
+     * requests. This FileAsyncResponseTransformer will write the content of the request to the file at the offset taken from the
+     * Content-Range header ('x-amz-content-range'). As such, we don't need to manually manage the state of the
      * AsyncResponseTransformer passed by the user, like we do for {@link SplittingTransformer}. Here, we know it is a
-     * FileAsyncResponseTransformer, so we can just ignore it, and instead rely on the individual FileAsyncResponseTransformer
-     * of every part.
+     * FileAsyncResponseTransformer, so we can just ignore it, and instead rely on the individual FileAsyncResponseTransformer of
+     * every part.
      * <p>
      * Note on retries: since we are delegating requests to {@link FileAsyncResponseTransformer}, each request made with this
-     * transformer will retry independently based on the retry configuration of the client it is used with. We only need to
-     * verify the completion state of the future of each individually
+     * transformer will retry independently based on the retry configuration of the client it is used with. We only need to verify
+     * the completion state of the future of each individually
      */
     class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
-        private final FileAsyncResponseTransformer<T> delegate;
-
-        IndividualFileTransformer(FileAsyncResponseTransformer<T> delegate) {
-            this.delegate = delegate;
-        }
+        private AsyncResponseTransformer<T, T> delegate;
+        private CompletableFuture<T> future;
 
         @Override
         public CompletableFuture<T> prepare() {
-            return delegate.prepare(); // this future will be completed once the body has been written to file
+            this.future = new CompletableFuture<>();
+            return this.future;
         }
 
         @Override
         public void onResponse(T response) {
-            log.info(() -> "Received response: " + response.toString());
-            // todo: move to s3 package to use GetObjectResponse?
+            // log.info(() -> "Received response: " + response.toString());
             List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
-            if (!CollectionUtils.isNullOrEmpty(contentRangeList)) {
-                String contentRange = contentRangeList.get(0);
-                log.info(() -> "Setting offset to " + contentRange);
-                ContentRangeParser.range(contentRange)
-                                  .ifPresent(pair -> delegate.offsetPosition(initialPosition + pair.left()));
+            if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
+                // Bad state! This is intended to cancel everything, no retries!
+                subscriber.onError(new IllegalStateException("Content range header is missing"));
+                return;
+            }
+
+            String contentRange = contentRangeList.get(0);
+            Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
+            if (!contentRangePair.isPresent()) {
+                // Bad state! This is intended to cancel everything, no retries!
+                subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
+                return;
             }
+
+            this.delegate = getDelegateTransformer(contentRangePair.get().left());
+            CompletableFuture<T> delegateFuture = delegate.prepare();
+            CompletableFutureUtils.forwardResultTo(delegateFuture, future);
+            CompletableFutureUtils.forwardExceptionTo(future, delegateFuture);
+            transformerSent.incrementAndGet();
             delegate.onResponse(response);
         }
 
+        private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
+            // todo deal with APPEND mode
+            if (transformerSent.get() == 0) {
+                return AsyncResponseTransformer.toFile(path, initialConfig);
+            }
+            FileTransformerConfiguration newConfig = initialConfig.copy(c -> c
+                .fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)
+                .position(startAt));
+            return AsyncResponseTransformer.toFile(path, newConfig);
+        }
+
         @Override
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
-            delegate.onStream(publisher);
+            if (delegate != null) {
+                delegate.onStream(publisher);
+            }
         }
 
         @Override
         public void exceptionOccurred(Throwable error) {
-            delegate.exceptionOccurred(error);
+            log.error(() -> "error detected", error);
+            if (delegate != null) {
+                // do not call onError, because exceptionOccurred may be called multiple times due to retries, simply forward the
+                // error to the delegate
+                delegate.exceptionOccurred(error);
+            } else {
+                // If we received an error without even having a delegate, this means we have thrown an error before even calling
+                // onStream on it something really wrong is happening, signal the subscriber to just shut down completely
+                subscriber.onError(error);
+            }
         }
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
index c47bc33b2af1..cffa2ec62a7a 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
@@ -20,8 +20,10 @@
 import java.util.function.Supplier;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
+import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.utils.Logger;
 
+@SdkInternalApi
 public class ThreadSafeEmittingSubscription<T> implements Subscription {
 
     private final AtomicBoolean emitting = new AtomicBoolean(false);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 9a5ca05c1236..3357f7f99d71 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -48,32 +48,31 @@ public <T> CompletableFuture<T> downloadObject(
             asyncResponseTransformer.split(SplittingTransformerConfiguration.builder()
                                                                             .bufferSizeInBytes(bufferSizeInBytes)
                                                                             .build());
-        if (!split.supportParallel()) {
-            return downloadPartsLinear(getObjectRequest, split);
+        if (!split.supportsNonSerial()) {
+            return downloadPartsSerially(getObjectRequest, split);
         }
 
-        // The publisher of AsyncResponseTransformer needs to know about s3 GetObjectResponse to write to the correct file offset.
-        // The default publisher in the SplitResult may not be able to do so, so we need to create a new one that knows about s3
         log.info(() -> "================= USING downloadPartsNonLinear ==================");
-        return downloadPartsNonLinear(getObjectRequest, asyncResponseTransformer, split);
+        return downloadPartsNonSerially(getObjectRequest, split);
 
     }
 
-    private <T> CompletableFuture<T> downloadPartsNonLinear(
+    private <T> CompletableFuture<T> downloadPartsNonSerially(
         GetObjectRequest getObjectRequest,
-        AsyncResponseTransformer<GetObjectResponse, T> asyncResponseTransformer,
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
         // TODO pause & resume
-        FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
+        // The publisher of AsyncResponseTransformer needs to know about s3 GetObjectResponse to write to the correct file offset.
+        // The default publisher in the SplitResult may not be able to do so, so we need to create a new one that knows about s3
+        // FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
+        //     new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
             s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture());
-        publisher.subscribe(subscriber);
+        split.publisher().subscribe(subscriber);
         return split.resultFuture();
     }
 
-    private <T> CompletableFuture<T> downloadPartsLinear(GetObjectRequest getObjectRequest,
-                                                         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
+    private <T> CompletableFuture<T> downloadPartsSerially(GetObjectRequest getObjectRequest,
+                                                           AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
         MultipartDownloaderSubscriber subscriber = subscriber(getObjectRequest);
         split.publisher().subscribe(subscriber);
         return split.resultFuture();
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index c8476d5bbcf8..5cec9142c86d 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -16,8 +16,11 @@
 package software.amazon.awssdk.services.s3.internal.multipart;
 
 import java.util.ArrayDeque;
+import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.ReentrantLock;
 import org.reactivestreams.Subscriber;
@@ -34,7 +37,7 @@
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
     private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
-    private static final int MAX_IN_FLIGHT = 8;
+    private static final int MAX_IN_FLIGHT = 16;
 
     /**
      * The s3 client used to make the individual part requests
@@ -67,7 +70,8 @@ public class NonLinearMultipartDownloaderSubscriber
     private final CompletableFuture<GetObjectResponse> resultFuture;
 
     /**
-     * The {@link GetObjectResponse} to be returned in the completed future to the user. It corresponds to the first part
+     * The {@link GetObjectResponse} to be returned in the completed future to the user. It corresponds to the response of first
+     * part GetObject
      */
     private GetObjectResponse getObjectResponse;
 
@@ -82,24 +86,35 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private volatile Integer totalParts;
 
-
     /**
      * The etag of the object being downloaded.
      */
     private volatile String eTag;
 
     /**
-     * The amount of in flights requests
+     * Tracks request that are currently in flights, waiting to be completed. Once completed, future are removed from the map
      */
-    private final AtomicInteger inFlights = new AtomicInteger();
+    private final Map<Integer, CompletableFuture<GetObjectResponse>> inFlightRequests = new ConcurrentHashMap<>();
 
+    /**
+     * Lock used during first part, so that the first batch of requests wait to be executed until we know if the s3 object is
+     * multipart or not.
+     */
     private final ReentrantLock firstPartLock = new ReentrantLock();
+
+    /**
+     * Pending transformers waiting for the first request to be executed. We cant execute multiple part get until the first
+     * requests completes, and we know the object in s3 is a multipart object.
+     */
     private final Queue<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> pendingTransformers = new ArrayDeque<>();
-    private volatile boolean firstRequestSent = false;
+
+    /**
+     * Tracks if the first request was sent
+     */
+    private final AtomicBoolean firstRequestSent = new AtomicBoolean(false);
 
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture) {
-        System.out.println("[DEBUG] NonLinearMultipartDownloaderSubscriber constructor called");
         this.s3 = s3;
         this.getObjectRequest = getObjectRequest;
         this.resultFuture = resultFuture;
@@ -112,7 +127,7 @@ public void onSubscribe(Subscription s) {
             return;
         }
         this.subscription = s;
-        this.subscription.request(MAX_IN_FLIGHT);
+        this.subscription.request(1);
     }
 
     @Override
@@ -135,42 +150,47 @@ public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse
     // We need to wait for the first request to finish so we know if it is aa multipart object or not.
     // While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
     private boolean handleFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        if (completedParts.get() == 0) {
-            firstPartLock.lock();
-            try {
-                if (!firstRequestSent) {
-                    sendFirstRequest(asyncResponseTransformer);
-                    firstRequestSent = true;
-                    return true;
-                }
-
-                // First request already sent, queue this transformer
-                synchronized (pendingTransformers) {
-                    pendingTransformers.offer(asyncResponseTransformer);
-                }
-            } finally {
-                firstPartLock.unlock();
+        if (completedParts.get() != 0) {
+            return false;
+        }
+
+        firstPartLock.lock();
+        try {
+            if (!firstRequestSent.get()) {
+                sendFirstRequest(asyncResponseTransformer);
+                firstRequestSent.set(true);
+                return true;
             }
-            return true;
+
+            // First request already sent, queue this transformer
+            synchronized (pendingTransformers) {
+                pendingTransformers.offer(asyncResponseTransformer);
+            }
+        } finally {
+            firstPartLock.unlock();
         }
-        return false;
+        return true;
     }
 
     private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         // guardrails: we shouldn't send more requests than
-        if (inFlights.get() + completedParts.get() >= totalParts) {
+        if (inFlightRequests.size() + completedParts.get() >= totalParts) {
             return;
         }
 
         int partToGet = nextPart();
         GetObjectRequest request = nextRequest(partToGet);
-        inFlights.incrementAndGet();
-        log.info(() -> "============== Sending next request for part: '" + partToGet + "' ==============");
+        // inFlights.incrementAndGet();
+        log.info(() -> "Sending next request for part: '" + partToGet);
         CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
+        inFlightRequests.put(partToGet, response);
+        log.info(() -> "Total in flight parts: " + inFlightRequests.size());
         response.whenComplete((res, e) -> {
-            log.info(() -> "============== Completed part: '" + partToGet + "' ==============");
-            inFlights.decrementAndGet();
+            log.info(() -> "Completed part: '" + partToGet);
+            inFlightRequests.remove(partToGet);
+            log.info(() -> "Total in flight parts: " + inFlightRequests.size());
             if (e != null) {
+                inFlightRequests.values().forEach(future -> future.cancel(true));
                 resultFuture.completeExceptionally(e);
                 return;
             }
@@ -186,23 +206,24 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
 
     // returns true if the first request was sent and is still in flight
     private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        log.info(() -> "============== SENDING FIRST REQUEST ==============");
+        log.info(() -> "Sending first request");
         GetObjectRequest request = nextRequest(1);
-        inFlights.incrementAndGet();
+        // inFlights.incrementAndGet();
         CompletableFuture<GetObjectResponse> responseFuture = s3.getObject(request, asyncResponseTransformer);
+        inFlightRequests.put(1, responseFuture);
 
         // Propagate cancellation from user
         CompletableFutureUtils.forwardExceptionTo(resultFuture, responseFuture);
 
         responseFuture.whenComplete((res, e) -> {
-            inFlights.decrementAndGet();
+            inFlightRequests.remove(1);
             if (e != null) {
-                // Note on retries: When this future completed exceptionally, it means we did all retries and still failed
-                // we need to report back the failure to the user.
+                // Note on retries: When this future completed exceptionally, it means we did all retries and still failed for
+                // that part. We need to report back the failure to the user.
+                inFlightRequests.values().forEach(future -> future.cancel(true));
                 resultFuture.completeExceptionally(e);
                 return;
             }
-            completedParts.incrementAndGet();
             Integer partCount = res.partsCount();
             eTag = res.eTag();
             if (partCount != null && totalParts == null) {
@@ -212,6 +233,7 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
                 totalParts = partCount;
             }
 
+            completedParts.incrementAndGet();
             // it is a multipart object?
             if (totalParts == null || totalParts == 1) {
                 // Single part object detected, skip multipart and complete everything now
@@ -227,17 +249,17 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
                 allRemainingParts.add(i);
             }
             getObjectResponse = res;
-            
+
             // Process pending transformers
             processPendingTransformers();
-            
+
             subscription.request(1);
         });
     }
 
     private void processPendingTransformers() {
         synchronized (pendingTransformers) {
-            AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer =  pendingTransformers.poll();
+            AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = pendingTransformers.poll();
             while (transformer != null) {
                 sendNextRequest(transformer);
                 transformer = pendingTransformers.poll();
@@ -246,8 +268,8 @@ private void processPendingTransformers() {
     }
 
     private void requestMoreIfNeeded() {
-        if (!allPartsCompletedOrInFlights() && inFlights.get() < MAX_IN_FLIGHT) {
-            log.info(() -> "requesting next part");
+        if (!allPartsCompletedOrInFlights() && inFlightRequests.size() < MAX_IN_FLIGHT) {
+            log.info(() -> "Requesting next part");
             subscription.request(1);
         }
     }
@@ -259,12 +281,14 @@ private Integer nextPart() {
     }
 
     private boolean allPartsCompletedOrInFlights() {
-        return inFlights.get() + completedParts.get() >= totalParts;
+        return inFlightRequests.size() + completedParts.get() >= totalParts;
     }
 
     @Override
     public void onError(Throwable t) {
-
+        // signal received from the publisher this is subscribed to
+        // failed state, something really wrong has happened, cancel everything
+        resultFuture.completeExceptionally(t);
     }
 
     @Override
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
index 708972b6b0d7..3536f40e1916 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
@@ -95,4 +95,15 @@ public byte[] stubForPartSuccess(int part, int totalPart, int partSize) {
                             .withBody(body)));
         return body;
     }
+
+    public byte[] stubSinglePart(String testBucket, String testKey, int partSize) {
+        byte[] body = new byte[partSize];
+        random.nextBytes(body);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))).willReturn(
+            aResponse()
+                .withHeader("x-amz-mp-parts-count", "1")
+                .withHeader("ETag", eTag)
+                .withBody(body)));
+        return body;
+    }
 }

From c44a5207390358ced7a4e846aefc681a6aad3c0c Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 22 Aug 2025 12:08:26 -0400
Subject: [PATCH 08/41] Wiremock test for s3AsyncClient with
 AsyncResponseTransformer.toFile

---
 .../async/FileAsyncResponseTransformer.java   |   1 +
 ...FileAsyncResponseTransformerPublisher.java |  14 +-
 ...AsyncResponseTransformerPublisherTest.java | 249 +++++++++++++++++
 ...onLinearMultipartDownloaderSubscriber.java |   4 +-
 .../multipart/MultipartDownloadTestUtil.java  |  11 +-
 ...ipartDownloaderSubscriberWiremockTest.java | 136 ++++++++++
 .../S3MultipartFileDownloadWiremockTest.java  | 251 ++++++++++++++++++
 7 files changed, 658 insertions(+), 8 deletions(-)
 create mode 100644 core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
 create mode 100644 services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
 create mode 100644 services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 17c123d663d5..977e157cb1a2 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -175,6 +175,7 @@ public void exceptionOccurred(Throwable throwable) {
             }
         }
         if (cf != null) {
+            log.info(() -> "completing file future exceptionally");
             cf.completeExceptionally(throwable);
         } else {
             log.warn(() -> "An exception occurred before the call to prepare() was able to instantiate the CompletableFuture."
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 375df818f5e5..5da2d06eb953 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -108,16 +108,17 @@ class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
 
         @Override
         public CompletableFuture<T> prepare() {
+            log.info(() -> "prepare() called");
             this.future = new CompletableFuture<>();
             return this.future;
         }
 
         @Override
         public void onResponse(T response) {
-            // log.info(() -> "Received response: " + response.toString());
+            log.info(() -> "Received response: " + response.toString());
             List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
             if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
-                // Bad state! This is intended to cancel everything, no retries!
+                // Bad state! This is intended to cancel everything
                 subscriber.onError(new IllegalStateException("Content range header is missing"));
                 return;
             }
@@ -125,7 +126,7 @@ public void onResponse(T response) {
             String contentRange = contentRangeList.get(0);
             Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
             if (!contentRangePair.isPresent()) {
-                // Bad state! This is intended to cancel everything, no retries!
+                // Bad state! This is intended to cancel everything
                 subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
                 return;
             }
@@ -151,6 +152,7 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
 
         @Override
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
+            log.info(() -> "onStream() called");
             if (delegate != null) {
                 delegate.onStream(publisher);
             }
@@ -165,8 +167,10 @@ public void exceptionOccurred(Throwable error) {
                 delegate.exceptionOccurred(error);
             } else {
                 // If we received an error without even having a delegate, this means we have thrown an error before even calling
-                // onStream on it something really wrong is happening, signal the subscriber to just shut down completely
-                subscriber.onError(error);
+                // onResponse.
+                if (future != null) {
+                    future.completeExceptionally(error);
+                }
             }
         }
     }
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
new file mode 100644
index 000000000000..da752b4673d5
--- /dev/null
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import java.nio.ByteBuffer;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import software.amazon.awssdk.core.SdkResponse;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
+import software.amazon.awssdk.http.SdkHttpResponse;
+import software.amazon.awssdk.utils.CompletableFutureUtils;
+
+class FileAsyncResponseTransformerPublisherTest {
+
+    private FileSystem fileSystem;
+    private Path testFile;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        testFile = fileSystem.getPath("/test-file.txt");
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        fileSystem.close();
+    }
+
+    @Test
+    void happyPath_singleOnNext() throws Exception {
+        // Given
+        AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
+
+        FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
+            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
+
+        CountDownLatch latch = new CountDownLatch(1);
+        AtomicReference<AsyncResponseTransformer<SdkResponse, SdkResponse>> receivedTransformer = new AtomicReference<>();
+        CompletableFuture<SdkResponse> future = new CompletableFuture<>();
+
+        // When
+        publisher.subscribe(new Subscriber<AsyncResponseTransformer<SdkResponse, SdkResponse>>() {
+            private Subscription subscription;
+
+            @Override
+            public void onSubscribe(Subscription s) {
+                this.subscription = s;
+                s.request(1);
+            }
+
+            @Override
+            public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transformer) {
+                receivedTransformer.set(transformer);
+
+                // Simulate response with content-range header
+                SdkResponse mockResponse = createMockResponse();
+                CompletableFuture<SdkResponse> prepareFuture = transformer.prepare();
+                CompletableFutureUtils.forwardResultTo(prepareFuture, future);
+                transformer.onResponse(mockResponse);
+
+                // Simulate stream data
+                SdkPublisher<ByteBuffer> mockPublisher = createMockPublisher();
+                transformer.onStream(mockPublisher);
+
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                latch.countDown();
+            }
+
+            @Override
+            public void onComplete() {
+                latch.countDown();
+            }
+        });
+
+        // Then
+        assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue();
+        assertThat(receivedTransformer.get()).isNotNull();
+        assertThat(Files.exists(testFile)).isTrue();
+        assertThat(future).isCompleted();
+    }
+
+    private SdkResponse createMockResponse() {
+        SdkResponse mockResponse = mock(SdkResponse.class);
+        SdkHttpResponse mockHttpResponse = mock(SdkHttpResponse.class);
+
+        when(mockResponse.sdkHttpResponse()).thenReturn(mockHttpResponse);
+        when(mockHttpResponse.headers()).thenReturn(
+            Collections.singletonMap("x-amz-content-range", Collections.singletonList("bytes 0-9/10"))
+        );
+
+        return mockResponse;
+    }
+
+    private SdkPublisher<ByteBuffer> createMockPublisher() {
+        return s -> s.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                s.onNext(ByteBuffer.wrap("test data".getBytes()));
+                s.onComplete();
+            }
+
+            @Override
+            public void cancel() {
+            }
+        });
+    }
+
+    @Test
+    void multipleOnNext_differentContentRanges() throws Exception {
+        // Given
+        AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
+        FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
+            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
+
+        int numTransformers = 8;
+        CountDownLatch latch = new CountDownLatch(numTransformers);
+        AtomicInteger transformerCount = new AtomicInteger(0);
+        List<CompletableFuture<SdkResponse>> futures = new ArrayList<>();
+
+        // When
+        publisher.subscribe(new Subscriber<AsyncResponseTransformer<SdkResponse, SdkResponse>>() {
+            @Override
+            public void onSubscribe(Subscription s) {
+                s.request(numTransformers);
+            }
+
+            @Override
+            public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transformer) {
+                int index = transformerCount.getAndIncrement();
+
+                // Each transformer gets a different 10-byte range
+                long startByte = index * 10L;
+                long endByte = startByte + 9;
+                String contentRange = String.format("bytes %d-%d/80", startByte, endByte);
+                byte[] data = new byte[10];
+                for (int i = 0; i < 10; i++) {
+                    data[i] = (byte) ((byte) startByte + i);
+                }
+
+                SdkResponse mockResponse = createMockResponseWithRange(contentRange);
+                CompletableFuture<SdkResponse> future = transformer.prepare();
+                futures.add(future);
+
+                transformer.onResponse(mockResponse);
+                transformer.onStream(createMockPublisherWithData(data));
+
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                for (int i = 0; i < numTransformers; i++) {
+                    latch.countDown();
+                }
+            }
+
+            @Override
+            public void onComplete() {
+            }
+        });
+
+        // Then
+        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
+        assertThat(transformerCount.get()).isEqualTo(numTransformers);
+
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] fileContent = Files.readAllBytes(testFile);
+
+        assertThat(fileContent.length).isEqualTo(80);
+
+        for (int i = 0; i < numTransformers; i++) {
+            int startPos = i * 10;
+            byte[] expectedData = new byte[10];
+            for (int j = 0; j < 10; j++) {
+                expectedData[j] = (byte) ((byte) startPos + j);
+            }
+            byte[] actualData = Arrays.copyOfRange(fileContent, startPos, startPos + 10);
+            assertThat(actualData).isEqualTo(expectedData);
+        }
+    }
+
+    private SdkResponse createMockResponseWithRange(String contentRange) {
+        SdkResponse mockResponse = mock(SdkResponse.class);
+        SdkHttpResponse mockHttpResponse = mock(SdkHttpResponse.class);
+
+        when(mockResponse.sdkHttpResponse()).thenReturn(mockHttpResponse);
+        when(mockHttpResponse.headers()).thenReturn(
+            Collections.singletonMap("x-amz-content-range", Collections.singletonList(contentRange))
+        );
+
+        return mockResponse;
+    }
+
+    private SdkPublisher<ByteBuffer> createMockPublisherWithData(byte[] data) {
+        return s -> s.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                s.onNext(ByteBuffer.wrap(data));
+                s.onComplete();
+            }
+
+            @Override
+            public void cancel() {
+            }
+        });
+    }
+
+}
\ No newline at end of file
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 5cec9142c86d..ce3be4a3363c 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -190,8 +190,8 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             inFlightRequests.remove(partToGet);
             log.info(() -> "Total in flight parts: " + inFlightRequests.size());
             if (e != null) {
-                inFlightRequests.values().forEach(future -> future.cancel(true));
                 resultFuture.completeExceptionally(e);
+                inFlightRequests.values().forEach(future -> future.cancel(true));
                 return;
             }
             completedParts.incrementAndGet();
@@ -220,8 +220,8 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             if (e != null) {
                 // Note on retries: When this future completed exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
-                inFlightRequests.values().forEach(future -> future.cancel(true));
                 resultFuture.completeExceptionally(e);
+                inFlightRequests.values().forEach(future -> future.cancel(true));
                 return;
             }
             Integer partCount = res.partsCount();
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
index 3536f40e1916..03ac08f75ecc 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
@@ -63,17 +63,25 @@ public byte[] stubAllParts(String testBucket, String testKey, int amountOfPartTo
         return expectedBody;
     }
 
-    public byte[] stubForPart(String testBucket, String testKey,int part, int totalPart, int partSize) {
+    public byte[] stubForPart(String testBucket, String testKey, int part, int totalPart, int partSize) {
         byte[] body = new byte[partSize];
         random.nextBytes(body);
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, part))).willReturn(
             aResponse()
                 .withHeader("x-amz-mp-parts-count", totalPart + "")
+                .withHeader("x-amz-content-range", contentRangeHeader(part, totalPart, partSize))
                 .withHeader("ETag", eTag)
                 .withBody(body)));
         return body;
     }
 
+    private String contentRangeHeader(int part, int totalPart, int partSize) {
+        long start = (part - 1) * (long) partSize;
+        long end = start + partSize - 1;
+        long total = totalPart * (long) partSize;
+        return String.format("bytes %d-%d/%d", start, end, total);
+    }
+
     public void verifyCorrectAmountOfRequestsMade(int amountOfPartToTest) {
         String urlTemplate = ".*partNumber=%d.*";
         for (int i = 1; i <= amountOfPartToTest; i++) {
@@ -102,6 +110,7 @@ public byte[] stubSinglePart(String testBucket, String testKey, int partSize) {
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))).willReturn(
             aResponse()
                 .withHeader("x-amz-mp-parts-count", "1")
+                .withHeader("x-amz-content-range", String.format("bytes %d-%d/%d", 0, partSize - 1, partSize))
                 .withHeader("ETag", eTag)
                 .withBody(body)));
         return body;
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
new file mode 100644
index 000000000000..ca9d4656c2f1
--- /dev/null
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.internal.multipart;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
+import com.github.tomakehurst.wiremock.junit5.WireMockTest;
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.CompletableFuture;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Subscriber;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.core.SplittingTransformerConfiguration;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.S3Configuration;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+
+@WireMockTest
+class NonLinearMultipartDownloaderSubscriberWiremockTest {
+
+    private final String testBucket = "test-bucket";
+    private final String testKey = "test-key";
+
+    private S3AsyncClient s3AsyncClient;
+    private MultipartDownloadTestUtil util;
+    private FileSystem fileSystem;
+    private Path testFile;
+
+    @BeforeEach
+    public void init(WireMockRuntimeInfo wiremock) throws Exception {
+        s3AsyncClient = S3AsyncClient.builder()
+                                     .credentialsProvider(StaticCredentialsProvider.create(
+                                         AwsBasicCredentials.create("key", "secret")))
+                                     .region(Region.US_WEST_2)
+                                     .endpointOverride(URI.create("http://localhost:" + wiremock.getHttpPort()))
+                                     .serviceConfiguration(S3Configuration.builder()
+                                                                          .pathStyleAccessEnabled(true)
+                                                                          .build())
+                                     .build();
+        util = new MultipartDownloadTestUtil(testBucket, testKey, "test-etag");
+        fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        testFile = fileSystem.getPath("/test-file.txt");
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        fileSystem.close();
+    }
+
+    @Test
+    void happyPath_multipartDownload() throws Exception {
+        int numParts = 4;
+        int partSize = 1024;
+        byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
+
+        AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = AsyncResponseTransformer.toFile(testFile);
+        AsyncResponseTransformer.SplitResult<GetObjectResponse, GetObjectResponse> split = transformer.split(
+            SplittingTransformerConfiguration.builder()
+                                             .bufferSizeInBytes(1024 * 32L)
+                                             .build());
+
+        CompletableFuture<GetObjectResponse> resultFuture = new CompletableFuture<>();
+        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber = 
+            new NonLinearMultipartDownloaderSubscriber(s3AsyncClient,
+                                                      GetObjectRequest.builder()
+                                                                      .bucket(testBucket)
+                                                                      .key(testKey)
+                                                                      .build(),
+                                                      resultFuture);
+
+        split.publisher().subscribe(subscriber);
+        GetObjectResponse getObjectResponse = resultFuture.join();
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] actualBody = Files.readAllBytes(testFile);
+        assertThat(actualBody).isEqualTo(expectedBody);
+        assertThat(getObjectResponse).isNotNull();
+        util.verifyCorrectAmountOfRequestsMade(numParts);
+    }
+
+    @Test
+    void singlePartObject_shouldCompleteWithoutMultipart() throws Exception {
+        int partSize = 1024;
+        byte[] expectedBody = util.stubSinglePart(testBucket, testKey, partSize);
+
+        AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = AsyncResponseTransformer.toFile(testFile);
+        AsyncResponseTransformer.SplitResult<GetObjectResponse, GetObjectResponse> split = transformer.split(
+            SplittingTransformerConfiguration.builder()
+                                             .bufferSizeInBytes(1024 * 32L)
+                                             .build());
+
+        CompletableFuture<GetObjectResponse> resultFuture = new CompletableFuture<>();
+        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber = 
+            new NonLinearMultipartDownloaderSubscriber(s3AsyncClient,
+                                                      GetObjectRequest.builder()
+                                                                      .bucket(testBucket)
+                                                                      .key(testKey)
+                                                                      .build(),
+                                                      resultFuture);
+
+        split.publisher().subscribe(subscriber);
+        GetObjectResponse getObjectResponse = resultFuture.join();
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] actualBody = Files.readAllBytes(testFile);
+        assertThat(actualBody).isEqualTo(expectedBody);
+        assertThat(getObjectResponse).isNotNull();
+        util.verifyCorrectAmountOfRequestsMade(1);
+    }
+
+}
\ No newline at end of file
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
new file mode 100644
index 000000000000..544d794354ad
--- /dev/null
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -0,0 +1,251 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.internal.multipart;
+
+import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
+import static com.github.tomakehurst.wiremock.client.WireMock.exactly;
+import static com.github.tomakehurst.wiremock.client.WireMock.get;
+import static com.github.tomakehurst.wiremock.client.WireMock.getRequestedFor;
+import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
+import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
+import static com.github.tomakehurst.wiremock.client.WireMock.urlMatching;
+import static com.github.tomakehurst.wiremock.client.WireMock.verify;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
+import com.github.tomakehurst.wiremock.junit5.WireMockTest;
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.S3Configuration;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+
+@WireMockTest
+class S3MultipartFileDownloadWiremockTest {
+
+    private final String testBucket = "test-bucket";
+    private final String testKey = "test-key";
+
+    private S3AsyncClient s3AsyncClient;
+    private MultipartDownloadTestUtil util;
+    private FileSystem fileSystem;
+    private Path testFile;
+
+    @BeforeEach
+    public void init(WireMockRuntimeInfo wiremock) throws Exception {
+        s3AsyncClient = S3AsyncClient.builder()
+                                     .credentialsProvider(StaticCredentialsProvider.create(
+                                         AwsBasicCredentials.create("key", "secret")))
+                                     .region(Region.US_WEST_2)
+                                     .endpointOverride(URI.create("http://localhost:" + wiremock.getHttpPort()))
+                                     .multipartEnabled(true)
+                                     .serviceConfiguration(S3Configuration.builder()
+                                                                          .pathStyleAccessEnabled(true)
+                                                                          .build())
+                                     .build();
+        util = new MultipartDownloadTestUtil(testBucket, testKey, "test-etag");
+        fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        testFile = fileSystem.getPath("/test-file.txt");
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        fileSystem.close();
+    }
+
+    @Test
+    void happyPath_singlePart() throws Exception {
+        int partSize = 1024;
+        byte[] expectedBody = util.stubSinglePart(testBucket, testKey, partSize);
+
+        GetObjectResponse response = s3AsyncClient.getObject(
+            GetObjectRequest.builder()
+                            .bucket(testBucket)
+                            .key(testKey)
+                            .build(),
+            AsyncResponseTransformer.toFile(testFile)
+        ).join();
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] actualBody = Files.readAllBytes(testFile);
+        assertThat(actualBody).isEqualTo(expectedBody);
+        assertThat(response).isNotNull();
+        util.verifyCorrectAmountOfRequestsMade(1);
+    }
+
+    @Test
+    void happyPath_multipart() throws Exception {
+        int numParts = 4;
+        int partSize = 1024;
+        byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
+
+        GetObjectResponse response = s3AsyncClient.getObject(
+            GetObjectRequest.builder()
+                            .bucket(testBucket)
+                            .key(testKey)
+                            .build(),
+            AsyncResponseTransformer.toFile(testFile)
+        ).join();
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] actualBody = Files.readAllBytes(testFile);
+        assertThat(actualBody).isEqualTo(expectedBody);
+        assertThat(response).isNotNull();
+        util.verifyCorrectAmountOfRequestsMade(numParts);
+    }
+
+    @Test
+    void errorOnFirstPart_nonRetryable() {
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))).willReturn(
+            aResponse()
+                .withStatus(403)
+                .withBody("<Error><Code>AccessDenied</Code><Message>Test: Access denied!</Message></Error>")));
+
+        CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
+                            .bucket(testBucket)
+                            .key(testKey)
+                            .build(),
+            AsyncResponseTransformer.toFile(testFile));
+        assertThat(resp).failsWithin(Duration.of(10, ChronoUnit.SECONDS))
+            .withThrowableOfType(ExecutionException.class)
+            .withCauseInstanceOf(S3Exception.class)
+            .withMessageContaining("Test: Access denied!");
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
+    }
+
+    @Test
+    void errorOnFirstPart_retryable() {
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("Started")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 1</Message></Error>"))
+                    .willSetStateTo("retry1"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry1")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 2</Message></Error>"))
+                    .willSetStateTo("retry2"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 3</Message></Error>"))
+        .willSetStateTo("retry3"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry3")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 4</Message></Error>")));
+
+        CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
+                                                                                .bucket(testBucket)
+                                                                                .key(testKey)
+                                                                                .build(),
+                                                                            AsyncResponseTransformer.toFile(testFile));
+        assertThat(resp).failsWithin(Duration.of(10, ChronoUnit.SECONDS))
+                        .withThrowableOfType(ExecutionException.class)
+                        .withCauseInstanceOf(S3Exception.class)
+                        .withMessageContaining("Internal error 4");
+        verify(exactly(4), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
+    }
+
+    @Test
+    void errorOnMiddlePart_nonRetryable() {
+        util.stubForPart(testBucket, testKey, 1, 3, 1024);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))).willReturn(
+            aResponse()
+                .withStatus(403)
+                .withBody("<Error><Code>AccessDenied</Code><Message>Test: Access denied!</Message></Error>")));
+        util.stubForPart(testBucket, testKey, 3, 3, 1024);
+
+        CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
+                                                                                .bucket(testBucket)
+                                                                                .key(testKey)
+                                                                                .build(),
+                                                                            AsyncResponseTransformer.toFile(testFile));
+
+        assertThat(resp).failsWithin(Duration.of(10, ChronoUnit.SECONDS))
+                        .withThrowableOfType(ExecutionException.class)
+                        .withCauseInstanceOf(S3Exception.class)
+                        .withMessageContaining("Test: Access denied!");
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))));
+    }
+
+    @Test
+    void errorOnMiddlePart_retryable() {
+        util.stubForPart(testBucket, testKey, 1, 3, 1024);
+        util.stubForPart(testBucket, testKey, 3, 3, 1024);
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("Started")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>"))
+                    .willSetStateTo("retry1"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry1")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>"))
+                    .willSetStateTo("retry2"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>")));
+
+        assertThatThrownBy(() -> s3AsyncClient.getObject(
+            GetObjectRequest.builder()
+                            .bucket(testBucket)
+                            .key(testKey)
+                            .build(),
+            AsyncResponseTransformer.toFile(testFile)
+        ).join()).hasMessageContaining("Internal error");
+    }
+}
\ No newline at end of file

From 418dcbdc4f9a52d33512bce38ce47447fb6242ef Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 22 Aug 2025 12:31:27 -0400
Subject: [PATCH 09/41] added 10_000 parts tests

---
 ...FileAsyncResponseTransformerPublisher.java |  8 ++--
 ...onLinearMultipartDownloaderSubscriber.java |  3 +-
 .../S3MultipartFileDownloadWiremockTest.java  | 43 +++++++++++++------
 3 files changed, 38 insertions(+), 16 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 5da2d06eb953..b2b178bb57af 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -154,6 +154,7 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
             log.info(() -> "onStream() called");
             if (delegate != null) {
+                // should never be null as per AsyncResponseTransformer runtime contract, but we never know
                 delegate.onStream(publisher);
             }
         }
@@ -163,11 +164,12 @@ public void exceptionOccurred(Throwable error) {
             log.error(() -> "error detected", error);
             if (delegate != null) {
                 // do not call onError, because exceptionOccurred may be called multiple times due to retries, simply forward the
-                // error to the delegate
+                // error to the delegate async response transformer which will let the service call pipeline handle the error.
                 delegate.exceptionOccurred(error);
             } else {
-                // If we received an error without even having a delegate, this means we have thrown an error before even calling
-                // onResponse.
+                // If we received an error without even having a delegate, this means we have thrown an error before even
+                // getting a onResponse signal. We complete the prepared future, to let the
+                // service call pipeline handle the error
                 if (future != null) {
                     future.completeExceptionally(error);
                 }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index ce3be4a3363c..4823bef9d991 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -286,7 +286,8 @@ private boolean allPartsCompletedOrInFlights() {
 
     @Override
     public void onError(Throwable t) {
-        // signal received from the publisher this is subscribed to
+        // Signal received from the publisher this is subscribed to, in the case of file download, that's
+        // FileAsyncResponseTransformerPublisher.
         // failed state, something really wrong has happened, cancel everything
         resultFuture.completeExceptionally(t);
     }
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index 544d794354ad..8c740b9c78b1 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -89,14 +89,13 @@ void happyPath_singlePart() throws Exception {
         int partSize = 1024;
         byte[] expectedBody = util.stubSinglePart(testBucket, testKey, partSize);
 
-        GetObjectResponse response = s3AsyncClient.getObject(
-            GetObjectRequest.builder()
+        CompletableFuture<GetObjectResponse> response = s3AsyncClient.getObject(b -> b
                             .bucket(testBucket)
                             .key(testKey)
                             .build(),
-            AsyncResponseTransformer.toFile(testFile)
-        ).join();
+            AsyncResponseTransformer.toFile(testFile));
 
+        assertThat(response).succeedsWithin(Duration.of(10, ChronoUnit.SECONDS));
         assertThat(Files.exists(testFile)).isTrue();
         byte[] actualBody = Files.readAllBytes(testFile);
         assertThat(actualBody).isEqualTo(expectedBody);
@@ -110,15 +109,13 @@ void happyPath_multipart() throws Exception {
         int partSize = 1024;
         byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
 
-        GetObjectResponse response = s3AsyncClient.getObject(
-            GetObjectRequest.builder()
-                            .bucket(testBucket)
-                            .key(testKey)
-                            .build(),
-            AsyncResponseTransformer.toFile(testFile)
-        ).join();
+        CompletableFuture<GetObjectResponse> response = s3AsyncClient.getObject(b -> b
+                                                                                    .bucket(testBucket)
+                                                                                    .key(testKey)
+                                                                                    .build(),
+                                                                                AsyncResponseTransformer.toFile(testFile));
 
-        assertThat(Files.exists(testFile)).isTrue();
+        assertThat(response).succeedsWithin(Duration.of(10, ChronoUnit.SECONDS));
         byte[] actualBody = Files.readAllBytes(testFile);
         assertThat(actualBody).isEqualTo(expectedBody);
         assertThat(response).isNotNull();
@@ -248,4 +245,26 @@ void errorOnMiddlePart_retryable() {
             AsyncResponseTransformer.toFile(testFile)
         ).join()).hasMessageContaining("Internal error");
     }
+
+    @Test
+    void veryHighPartCount_shouldSucceed() throws Exception {
+        // 10_000_000 bytes -> 10MB total
+        int numParts = 10_000;
+        int partSize = 1000;
+
+        byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
+
+        CompletableFuture<GetObjectResponse> response = s3AsyncClient.getObject(b -> b
+                                                                                    .bucket(testBucket)
+                                                                                    .key(testKey)
+                                                                                    .build(),
+                                                                                AsyncResponseTransformer.toFile(testFile));
+
+        assertThat(response).succeedsWithin(Duration.of(2, ChronoUnit.MINUTES));
+        byte[] actualBody = Files.readAllBytes(testFile);
+        assertThat(actualBody).isEqualTo(expectedBody);
+        assertThat(response).isNotNull();
+        util.verifyCorrectAmountOfRequestsMade(numParts);
+
+    }
 }
\ No newline at end of file

From db7d30194b03ddaab39c5004c5d1063452d980ec Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 22 Aug 2025 12:45:17 -0400
Subject: [PATCH 10/41] add missing assertions to errorOnMiddlePart_retryable

---
 .../S3MultipartFileDownloadWiremockTest.java  | 35 +++++++++++++------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index 8c740b9c78b1..7d2cac43e83b 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -219,7 +219,7 @@ void errorOnMiddlePart_retryable() {
                     .whenScenarioStateIs("Started")
                     .willReturn(aResponse()
                                     .withStatus(500)
-                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>"))
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 1</Message></Error>"))
                     .willSetStateTo("retry1"));
 
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
@@ -227,7 +227,7 @@ void errorOnMiddlePart_retryable() {
                     .whenScenarioStateIs("retry1")
                     .willReturn(aResponse()
                                     .withStatus(500)
-                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>"))
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 2</Message></Error>"))
                     .willSetStateTo("retry2"));
 
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
@@ -235,15 +235,30 @@ void errorOnMiddlePart_retryable() {
                     .whenScenarioStateIs("retry2")
                     .willReturn(aResponse()
                                     .withStatus(500)
-                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error</Message></Error>")));
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 3</Message></Error>"))
+                    .willSetStateTo("retry3")
+        );
 
-        assertThatThrownBy(() -> s3AsyncClient.getObject(
-            GetObjectRequest.builder()
-                            .bucket(testBucket)
-                            .key(testKey)
-                            .build(),
-            AsyncResponseTransformer.toFile(testFile)
-        ).join()).hasMessageContaining("Internal error");
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry3")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 4</Message></Error>")));
+
+        CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
+                                                                                .bucket(testBucket)
+                                                                                .key(testKey)
+                                                                                .build(),
+                                                                            AsyncResponseTransformer.toFile(testFile));
+
+        assertThat(resp).failsWithin(Duration.of(10, ChronoUnit.SECONDS))
+                        .withThrowableOfType(ExecutionException.class)
+                        .withCauseInstanceOf(S3Exception.class)
+                        .withMessageContaining("Internal error 4");
+
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
+        verify(exactly(4), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))));
     }
 
     @Test

From 2f65a8c7decbfbf70589df7d4afe6bb77f4e78c6 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Mon, 25 Aug 2025 10:48:30 -0400
Subject: [PATCH 11/41] handle fileWriteOption

---
 .../core/async/AsyncResponseTransformer.java  |   5 +-
 .../async/FileAsyncResponseTransformer.java   | 118 ++++++++++++++-
 ...FileAsyncResponseTransformerPublisher.java |  69 +++++----
 .../core/internal/async/FileSubscriber.java   | 141 ------------------
 .../multipart/DownloadObjectHelper.java       |   4 -
 ...onLinearMultipartDownloaderSubscriber.java |   7 +-
 .../multipart/MultipartDownloadTestUtil.java  |   2 +-
 .../S3MultipartFileDownloadWiremockTest.java  | 116 ++++++++++++--
 8 files changed, 259 insertions(+), 203 deletions(-)
 delete mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
index 033542b929d7..44a704f30d10 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
@@ -349,8 +349,9 @@ interface SplitResult<ResponseT, ResultT>
         CompletableFuture<ResultT> resultFuture();
 
         /**
-         * TODO javadoc
-         * @return
+         * Indicates if the split async response transformer supports sending individual transformer non-serially, as well as
+         * receiving back data from the many {@link AsyncResponseTransformer#onStream(SdkPublisher) publishers} non-serially.
+         * @return true if non-serial data is supported, false otherwise
          */
         default Boolean supportsNonSerial() {
             return false;
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 977e157cb1a2..36756d93bb3f 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -23,6 +23,7 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.AsynchronousFileChannel;
+import java.nio.channels.CompletionHandler;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.OpenOption;
@@ -33,10 +34,13 @@
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.FileTransformerConfiguration.FailureBehavior;
-import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
@@ -188,8 +192,120 @@ public String name() {
         return TransformerType.FILE.getName();
     }
 
+    static class FileSubscriber implements Subscriber<ByteBuffer> {
+        private final AtomicLong position;
+        private final AsynchronousFileChannel fileChannel;
+        private final Path path;
+        private final CompletableFuture<Void> future;
+        private final Consumer<Throwable> onErrorMethod;
+
+        private volatile boolean writeInProgress = false;
+        private volatile boolean closeOnLastWrite = false;
+        private Subscription subscription;
+
+        FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
+                              Consumer<Throwable> onErrorMethod, long startingPosition) {
+            this.fileChannel = fileChannel;
+            this.path = path;
+            this.future = future;
+            this.onErrorMethod = onErrorMethod;
+            this.position = new AtomicLong(startingPosition);
+        }
+
+        @Override
+        public void onSubscribe(Subscription s) {
+            if (this.subscription != null) {
+                s.cancel();
+                return;
+            }
+            this.subscription = s;
+            // Request the first chunk to start producing content
+            s.request(1);
+        }
+
+        @Override
+        public void onNext(ByteBuffer byteBuffer) {
+            if (byteBuffer == null) {
+                throw new NullPointerException("Element must not be null");
+            }
+
+            performWrite(byteBuffer);
+        }
+
+        private void performWrite(ByteBuffer byteBuffer) {
+            writeInProgress = true;
+
+            fileChannel.write(byteBuffer, position.get(), byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
+                @Override
+                public void completed(Integer result, ByteBuffer attachment) {
+                    position.addAndGet(result);
+
+                    if (byteBuffer.hasRemaining()) {
+                        performWrite(byteBuffer);
+                    } else {
+                        synchronized (this) {
+                            writeInProgress = false;
+                            if (closeOnLastWrite) {
+                                close();
+                            } else {
+                                subscription.request(1);
+                            }
+                        }
+                    }
+                }
+
+                @Override
+                public void failed(Throwable exc, ByteBuffer attachment) {
+                    subscription.cancel();
+                    future.completeExceptionally(exc);
+                }
+            });
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            onErrorMethod.accept(t);
+        }
+
+        @Override
+        public void onComplete() {
+            log.trace(() -> "onComplete");
+            // if write in progress, tell write to close on finish.
+            synchronized (this) {
+                if (writeInProgress) {
+                    log.trace(() -> "writeInProgress = true, not closing");
+                    closeOnLastWrite = true;
+                } else {
+                    log.trace(() -> "writeInProgress = false, closing");
+                    close();
+                }
+            }
+        }
+
+        private void close() {
+            try {
+                if (fileChannel != null) {
+                    invokeSafely(fileChannel::close);
+                }
+                log.trace(() -> "Completing File async transformer future future");
+                future.complete(null);
+            } catch (RuntimeException exception) {
+                future.completeExceptionally(exception);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return getClass() + ":" + path.toString();
+        }
+    }
+
+
     @Override
     public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
+        if (configuration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
+            return AsyncResponseTransformer.super.split(splitConfig);
+        }
         return AsyncResponseTransformer.super
             .split(splitConfig)
             .copy(
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index b2b178bb57af..bc1d7e00c2c4 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -24,7 +24,6 @@
 import java.util.concurrent.atomic.AtomicLong;
 import org.reactivestreams.Subscriber;
 import software.amazon.awssdk.annotations.SdkInternalApi;
-import software.amazon.awssdk.annotations.SdkProtectedApi;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
@@ -40,12 +39,6 @@
 /**
  * A publisher of {@link FileAsyncResponseTransformer} that uses the Content-Range header of a {@link SdkResponse} to write to the
  * offset defined in the range of the Content-Range. Correspond to the {@link SplittingTransformer} for non-linear write cases.
- * Will only work for {@link FileAsyncResponseTransformer} and will throw {@link IllegalArgumentException} if other subclasses of
- * AsyncResponseTransformer is used with it.
- * <p>
- * Note: Marked as protected API because the s3 multipart logic in the s3 module needs to know about this type.
- *
- * @param <T>
  */
 @SdkInternalApi
 public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
@@ -55,33 +48,21 @@ public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
     private final Path path;
     private final FileTransformerConfiguration initialConfig;
     private final long initialPosition;
-    private Subscriber subscriber;
-    private AtomicLong transformerSent;
-
-    public FileAsyncResponseTransformerPublisher(AsyncResponseTransformer<?, ?> responseTransformer) {
-        Validate.isTrue(responseTransformer instanceof FileAsyncResponseTransformer,
-                        "Only FileAsyncResponseTransformer is supported for FileAsyncResponseTransformerPublisher");
-        FileAsyncResponseTransformer<SdkResponse> transformer = (FileAsyncResponseTransformer<SdkResponse>) responseTransformer;
-        this.path = Validate.paramNotNull(transformer.path(), "path");
-        this.initialConfig = Validate.paramNotNull(transformer.config(), "fileTransformerConfiguration");
-        this.initialPosition = transformer.initialPosition();
-        transformerSent = new AtomicLong();
+    private final AtomicLong amountOfTransformerSent;
+    private Subscriber<?> subscriber;
+
+    public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> responseTransformer) {
+        this.path = Validate.paramNotNull(responseTransformer.path(), "path");
+        this.initialConfig = Validate.paramNotNull(responseTransformer.config(), "fileTransformerConfiguration");
+        this.initialPosition = responseTransformer.initialPosition();
+        this.amountOfTransformerSent = new AtomicLong(0);
     }
 
     @Override
     public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
         this.subscriber = s;
         s.onSubscribe(new ThreadSafeEmittingSubscription<>(
-            s, new AtomicLong(0), this::onCancel, new AtomicBoolean(), log, this::createTransformer));
-    }
-
-    /**
-     * Signal received from {@link Subscriber} (the one receive from the subscribe method) to stop sending
-     * IndividualFileTransformer and clean-up resources. Not necessarily an error state.
-     */
-    private void onCancel() {
-        // do nothing. We have no resources to clean and the demand is managed by ThreadSafeEmittingSubscription which will
-        // already fulfill previously signaled demand
+            s, new AtomicLong(0), () -> {}, new AtomicBoolean(), log, this::createTransformer));
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
@@ -135,19 +116,37 @@ public void onResponse(T response) {
             CompletableFuture<T> delegateFuture = delegate.prepare();
             CompletableFutureUtils.forwardResultTo(delegateFuture, future);
             CompletableFutureUtils.forwardExceptionTo(future, delegateFuture);
-            transformerSent.incrementAndGet();
+            amountOfTransformerSent.incrementAndGet();
             delegate.onResponse(response);
         }
 
         private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
-            // todo deal with APPEND mode
-            if (transformerSent.get() == 0) {
+            if (amountOfTransformerSent.get() == 0) {
                 return AsyncResponseTransformer.toFile(path, initialConfig);
             }
-            FileTransformerConfiguration newConfig = initialConfig.copy(c -> c
-                .fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)
-                .position(startAt));
-            return AsyncResponseTransformer.toFile(path, newConfig);
+            switch (initialConfig.fileWriteOption()) {
+                case CREATE_NEW:
+                case CREATE_OR_REPLACE_EXISTING: {
+                    FileTransformerConfiguration newConfig = initialConfig.copy(c -> c
+                        .fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)
+                        .position(startAt));
+                    return AsyncResponseTransformer.toFile(path, newConfig);
+                }
+                case CREATE_OR_APPEND_TO_EXISTING: {
+                    // APPEND mode is not supported for non-serial operations,
+                    // we can just reuse the same config (with CREATE_OR_APPEND_TO_EXISTING) which will work serially
+                    return AsyncResponseTransformer.toFile(path, initialConfig);
+                }
+                case WRITE_TO_POSITION: {
+                    long initialOffset = initialConfig.position();
+                    FileTransformerConfiguration newConfig = initialConfig.copy(c -> c
+                        .fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)
+                        .position(initialOffset + startAt));
+                    return AsyncResponseTransformer.toFile(path, newConfig);
+                }
+                default:
+                    throw new UnsupportedOperationException("Unsupported fileWriteOption: " + initialConfig.fileWriteOption());
+            }
         }
 
         @Override
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java
deleted file mode 100644
index 844e78549481..000000000000
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSubscriber.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
- *
- *  http://aws.amazon.com/apache2.0
- *
- * or in the "license" file accompanying this file. This file is distributed
- * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package software.amazon.awssdk.core.internal.async;
-
-import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
-
-import java.nio.ByteBuffer;
-import java.nio.channels.AsynchronousFileChannel;
-import java.nio.channels.CompletionHandler;
-import java.nio.file.Path;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Consumer;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-import software.amazon.awssdk.utils.Logger;
-
-/**
- * {@link Subscriber} implementation that writes chunks to a file.
- */
-public class FileSubscriber implements Subscriber<ByteBuffer> {
-    private static final Logger log = Logger.loggerFor(FileSubscriber.class);
-    private final AtomicLong position;
-    private final AsynchronousFileChannel fileChannel;
-    private final Path path;
-    private final CompletableFuture<Void> future;
-    private final Consumer<Throwable> onErrorMethod;
-
-    private volatile boolean writeInProgress = false;
-    private volatile boolean closeOnLastWrite = false;
-    private Subscription subscription;
-
-    public FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
-                   Consumer<Throwable> onErrorMethod, long startingPosition) {
-        this.fileChannel = fileChannel;
-        this.path = path;
-        this.future = future;
-        this.onErrorMethod = onErrorMethod;
-        this.position = new AtomicLong(startingPosition);
-    }
-
-    @Override
-    public void onSubscribe(Subscription s) {
-        if (this.subscription != null) {
-            s.cancel();
-            return;
-        }
-        this.subscription = s;
-        // Request the first chunk to start producing content
-        s.request(1);
-    }
-
-    @Override
-    public void onNext(ByteBuffer byteBuffer) {
-        if (byteBuffer == null) {
-            throw new NullPointerException("Element must not be null");
-        }
-
-        performWrite(byteBuffer);
-    }
-
-    private void performWrite(ByteBuffer byteBuffer) {
-        writeInProgress = true;
-
-        fileChannel.write(byteBuffer, position.get(), byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
-            @Override
-            public void completed(Integer result, ByteBuffer attachment) {
-                position.addAndGet(result);
-
-                if (byteBuffer.hasRemaining()) {
-                    performWrite(byteBuffer);
-                } else {
-                    synchronized (FileSubscriber.this) {
-                        writeInProgress = false;
-                        if (closeOnLastWrite) {
-                            close();
-                        } else {
-                            subscription.request(1);
-                        }
-                    }
-                }
-            }
-
-            @Override
-            public void failed(Throwable exc, ByteBuffer attachment) {
-                subscription.cancel();
-                future.completeExceptionally(exc);
-            }
-        });
-    }
-
-    @Override
-    public void onError(Throwable t) {
-        onErrorMethod.accept(t);
-    }
-
-    @Override
-    public void onComplete() {
-        log.trace(() -> "onComplete");
-        // if write in progress, tell write to close on finish.
-        synchronized (this) {
-            if (writeInProgress) {
-                log.trace(() -> "writeInProgress = true, not closing");
-                closeOnLastWrite = true;
-            } else {
-                log.trace(() -> "writeInProgress = false, closing");
-                close();
-            }
-        }
-    }
-
-    private void close() {
-        try {
-            if (fileChannel != null) {
-                invokeSafely(fileChannel::close);
-            }
-            log.trace(() -> "Completing File async transformer future future");
-            future.complete(null);
-        } catch (RuntimeException exception) {
-            future.completeExceptionally(exception);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return getClass() + ":" + path.toString();
-    }
-}
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 3357f7f99d71..8868265de0d8 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -61,10 +61,6 @@ private <T> CompletableFuture<T> downloadPartsNonSerially(
         GetObjectRequest getObjectRequest,
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
         // TODO pause & resume
-        // The publisher of AsyncResponseTransformer needs to know about s3 GetObjectResponse to write to the correct file offset.
-        // The default publisher in the SplitResult may not be able to do so, so we need to create a new one that knows about s3
-        // FileAsyncResponseTransformerPublisher<GetObjectResponse> publisher =
-        //     new FileAsyncResponseTransformerPublisher<>(asyncResponseTransformer);
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
             s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture());
         split.publisher().subscribe(subscriber);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 4823bef9d991..b9b14a247fa7 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -173,14 +173,12 @@ private boolean handleFirstRequest(AsyncResponseTransformer<GetObjectResponse, G
     }
 
     private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        // guardrails: we shouldn't send more requests than
         if (inFlightRequests.size() + completedParts.get() >= totalParts) {
             return;
         }
 
         int partToGet = nextPart();
         GetObjectRequest request = nextRequest(partToGet);
-        // inFlights.incrementAndGet();
         log.info(() -> "Sending next request for part: '" + partToGet);
         CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
         inFlightRequests.put(partToGet, response);
@@ -190,6 +188,8 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             inFlightRequests.remove(partToGet);
             log.info(() -> "Total in flight parts: " + inFlightRequests.size());
             if (e != null) {
+                // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
+                // that part. We need to report back the failure to the user.
                 resultFuture.completeExceptionally(e);
                 inFlightRequests.values().forEach(future -> future.cancel(true));
                 return;
@@ -208,7 +208,6 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
     private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         log.info(() -> "Sending first request");
         GetObjectRequest request = nextRequest(1);
-        // inFlights.incrementAndGet();
         CompletableFuture<GetObjectResponse> responseFuture = s3.getObject(request, asyncResponseTransformer);
         inFlightRequests.put(1, responseFuture);
 
@@ -218,7 +217,7 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         responseFuture.whenComplete((res, e) -> {
             inFlightRequests.remove(1);
             if (e != null) {
-                // Note on retries: When this future completed exceptionally, it means we did all retries and still failed for
+                // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
                 resultFuture.completeExceptionally(e);
                 inFlightRequests.values().forEach(future -> future.cancel(true));
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
index 03ac08f75ecc..9523cfdf1c8f 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartDownloadTestUtil.java
@@ -75,7 +75,7 @@ public byte[] stubForPart(String testBucket, String testKey, int part, int total
         return body;
     }
 
-    private String contentRangeHeader(int part, int totalPart, int partSize) {
+    public static String contentRangeHeader(int part, int totalPart, int partSize) {
         long start = (part - 1) * (long) partSize;
         long end = start + partSize - 1;
         long total = totalPart * (long) partSize;
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index 7d2cac43e83b..f8e5b9f83e73 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -21,10 +21,9 @@
 import static com.github.tomakehurst.wiremock.client.WireMock.getRequestedFor;
 import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
-import static com.github.tomakehurst.wiremock.client.WireMock.urlMatching;
 import static com.github.tomakehurst.wiremock.client.WireMock.verify;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static software.amazon.awssdk.services.s3.internal.multipart.MultipartDownloadTestUtil.contentRangeHeader;
 
 import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
 import com.github.tomakehurst.wiremock.junit5.WireMockTest;
@@ -36,6 +35,9 @@
 import java.nio.file.Path;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import org.junit.jupiter.api.AfterEach;
@@ -47,7 +49,6 @@
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.S3Configuration;
-import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
 import software.amazon.awssdk.services.s3.model.S3Exception;
 
@@ -90,10 +91,10 @@ void happyPath_singlePart() throws Exception {
         byte[] expectedBody = util.stubSinglePart(testBucket, testKey, partSize);
 
         CompletableFuture<GetObjectResponse> response = s3AsyncClient.getObject(b -> b
-                            .bucket(testBucket)
-                            .key(testKey)
-                            .build(),
-            AsyncResponseTransformer.toFile(testFile));
+                                                                                    .bucket(testBucket)
+                                                                                    .key(testKey)
+                                                                                    .build(),
+                                                                                AsyncResponseTransformer.toFile(testFile));
 
         assertThat(response).succeedsWithin(Duration.of(10, ChronoUnit.SECONDS));
         assertThat(Files.exists(testFile)).isTrue();
@@ -130,14 +131,14 @@ void errorOnFirstPart_nonRetryable() {
                 .withBody("<Error><Code>AccessDenied</Code><Message>Test: Access denied!</Message></Error>")));
 
         CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
-                            .bucket(testBucket)
-                            .key(testKey)
-                            .build(),
-            AsyncResponseTransformer.toFile(testFile));
+                                                                                .bucket(testBucket)
+                                                                                .key(testKey)
+                                                                                .build(),
+                                                                            AsyncResponseTransformer.toFile(testFile));
         assertThat(resp).failsWithin(Duration.of(10, ChronoUnit.SECONDS))
-            .withThrowableOfType(ExecutionException.class)
-            .withCauseInstanceOf(S3Exception.class)
-            .withMessageContaining("Test: Access denied!");
+                        .withThrowableOfType(ExecutionException.class)
+                        .withCauseInstanceOf(S3Exception.class)
+                        .withMessageContaining("Test: Access denied!");
         verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
     }
 
@@ -165,7 +166,7 @@ void errorOnFirstPart_retryable() {
                     .willReturn(aResponse()
                                     .withStatus(500)
                                     .withBody("<Error><Code>InternalError</Code><Message>Internal error 3</Message></Error>"))
-        .willSetStateTo("retry3"));
+                    .willSetStateTo("retry3"));
 
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
                     .inScenario("retry")
@@ -261,6 +262,91 @@ void errorOnMiddlePart_retryable() {
         verify(exactly(4), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))));
     }
 
+    @Test
+    void errorOnMiddlePart_retryable_thenSucceeds() throws Exception {
+        int partSize = 1024;
+        int totalPart = 3;
+        List<Byte> expectedData = new ArrayList<>();
+        byte[] part1Data = util.stubForPart(testBucket, testKey, 1, totalPart, partSize);
+        for (byte b: part1Data) {
+            expectedData.add(b);
+        }
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("Started")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 1</Message></Error>"))
+                    .willSetStateTo("retry1"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry1")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 2</Message></Error>"))
+                    .willSetStateTo("retry2"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 3</Message></Error>"))
+                    .willSetStateTo("retry3")
+        );
+
+        byte[] part2Data = new byte[partSize];
+        new Random().nextBytes(part2Data);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 2)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry3")
+                    .willReturn(aResponse()
+                                    .withHeader("x-amz-mp-parts-count", totalPart + "")
+                                    .withHeader("x-amz-content-range", contentRangeHeader(2, totalPart, partSize))
+                                    .withHeader("ETag", "test-etag")
+                                    .withBody(part2Data)));
+        for (byte b: part2Data) {
+            expectedData.add(b);
+        }
+
+        byte[] part3Data = new byte[partSize];
+        new Random().nextBytes(part3Data);
+        for (byte b: part3Data) {
+            expectedData.add(b);
+        }
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 3)))
+                    .willReturn(aResponse()
+                                    .withHeader("x-amz-mp-parts-count", totalPart + "")
+                                    .withHeader("x-amz-content-range", contentRangeHeader(3, totalPart, partSize))
+                                    .withHeader("ETag", "test-etag")
+                                    .withBody(part3Data)));
+
+        CompletableFuture<GetObjectResponse> resp = s3AsyncClient.getObject(b -> b
+                                                                                .bucket(testBucket)
+                                                                                .key(testKey)
+                                                                                .build(),
+                                                                            AsyncResponseTransformer.toFile(testFile));
+
+        assertThat(resp).succeedsWithin(Duration.of(10, ChronoUnit.SECONDS));
+
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey))));
+        verify(exactly(4), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))));
+        verify(exactly(1), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=3", testBucket, testKey))));
+
+        assertThat(Files.exists(testFile)).isTrue();
+        byte[] actualBody = Files.readAllBytes(testFile);
+        byte[] expectedBody = new byte[partSize * totalPart];
+        System.arraycopy(part1Data, 0, expectedBody, 0, partSize);
+        System.arraycopy(part2Data, 0, expectedBody, partSize, partSize);
+        System.arraycopy(part3Data, 0, expectedBody, partSize * 2, partSize);
+        assertThat(actualBody).isEqualTo(expectedBody);
+
+    }
+
+
     @Test
     void veryHighPartCount_shouldSucceed() throws Exception {
         // 10_000_000 bytes -> 10MB total

From 0bfbdb248687b6843ab0de02c2d72008ecb958e2 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 27 Aug 2025 14:36:42 -0400
Subject: [PATCH 12/41] prevent over-requesting and fix potential race
 condition in FileSubscriber

---
 .../async/FileAsyncResponseTransformer.java   |   7 +-
 ...FileAsyncResponseTransformerPublisher.java |   3 -
 ...AsyncResponseTransformerPublisherTest.java |   4 +-
 .../internal/async/FileSubscriberTckTest.java |   4 +-
 .../multipart/DownloadObjectHelper.java       |   1 -
 ...onLinearMultipartDownloaderSubscriber.java | 103 ++++++++++++++----
 .../S3MultipartFileDownloadWiremockTest.java  |  92 ++++++++++++----
 7 files changed, 161 insertions(+), 53 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 36756d93bb3f..f827589aabeb 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -60,7 +60,7 @@ public final class FileAsyncResponseTransformer<ResponseT> implements AsyncRespo
     private volatile AsynchronousFileChannel fileChannel;
     private volatile CompletableFuture<Void> cf;
     private volatile ResponseT response;
-    private long position;
+    private final long position;
     private final FileTransformerConfiguration configuration;
 
     public FileAsyncResponseTransformer(Path path) {
@@ -198,6 +198,7 @@ static class FileSubscriber implements Subscriber<ByteBuffer> {
         private final Path path;
         private final CompletableFuture<Void> future;
         private final Consumer<Throwable> onErrorMethod;
+        private final Object closeLock = new Object();
 
         private volatile boolean writeInProgress = false;
         private volatile boolean closeOnLastWrite = false;
@@ -243,7 +244,7 @@ public void completed(Integer result, ByteBuffer attachment) {
                     if (byteBuffer.hasRemaining()) {
                         performWrite(byteBuffer);
                     } else {
-                        synchronized (this) {
+                        synchronized (closeLock) {
                             writeInProgress = false;
                             if (closeOnLastWrite) {
                                 close();
@@ -271,7 +272,7 @@ public void onError(Throwable t) {
         public void onComplete() {
             log.trace(() -> "onComplete");
             // if write in progress, tell write to close on finish.
-            synchronized (this) {
+            synchronized (closeLock) {
                 if (writeInProgress) {
                     log.trace(() -> "writeInProgress = true, not closing");
                     closeOnLastWrite = true;
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index bc1d7e00c2c4..840c22b2ebf3 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -89,14 +89,12 @@ class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
 
         @Override
         public CompletableFuture<T> prepare() {
-            log.info(() -> "prepare() called");
             this.future = new CompletableFuture<>();
             return this.future;
         }
 
         @Override
         public void onResponse(T response) {
-            log.info(() -> "Received response: " + response.toString());
             List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
             if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
                 // Bad state! This is intended to cancel everything
@@ -151,7 +149,6 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
 
         @Override
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
-            log.info(() -> "onStream() called");
             if (delegate != null) {
                 // should never be null as per AsyncResponseTransformer runtime contract, but we never know
                 delegate.onStream(publisher);
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index da752b4673d5..42fa4d939ce6 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -67,7 +67,7 @@ void happyPath_singleOnNext() throws Exception {
         AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
 
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
+            new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<?>) initialTransformer);
 
         CountDownLatch latch = new CountDownLatch(1);
         AtomicReference<AsyncResponseTransformer<SdkResponse, SdkResponse>> receivedTransformer = new AtomicReference<>();
@@ -149,7 +149,7 @@ void multipleOnNext_differentContentRanges() throws Exception {
         // Given
         AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
+            new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<?>) initialTransformer);
 
         int numTransformers = 8;
         CountDownLatch latch = new CountDownLatch(numTransformers);
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
index 7690afaeadce..1937de5220e1 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
@@ -33,7 +33,7 @@
 import org.reactivestreams.tck.TestEnvironment;
 
 /**
- * TCK verification test for {@link FileSubscriber}.
+ * TCK verification test for {@link FileAsyncResponseTransformer.FileSubscriber}.
  */
 public class FileSubscriberTckTest extends SubscriberWhiteboxVerification<ByteBuffer> {
     private static final byte[] CONTENT = new byte[16];
@@ -46,7 +46,7 @@ public FileSubscriberTckTest() {
     @Override
     public Subscriber<ByteBuffer> createSubscriber(WhiteboxSubscriberProbe<ByteBuffer> whiteboxSubscriberProbe) {
         Path tempFile = getNewTempFile();
-        return new FileSubscriber(openChannel(tempFile), tempFile, new CompletableFuture<>(), (t) -> {}, 0) {
+        return new FileAsyncResponseTransformer.FileSubscriber(openChannel(tempFile), tempFile, new CompletableFuture<>(), (t) -> {}, 0) {
             @Override
             public void onSubscribe(Subscription s) {
                 super.onSubscribe(s);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 8868265de0d8..e313bf9917c5 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -20,7 +20,6 @@
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
-import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformerPublisher;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index b9b14a247fa7..af38b4bb131b 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -37,7 +37,7 @@
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
     private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
-    private static final int MAX_IN_FLIGHT = 16;
+    private static final int MAX_IN_FLIGHT = 50;
 
     /**
      * The s3 client used to make the individual part requests
@@ -113,6 +113,11 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicBoolean firstRequestSent = new AtomicBoolean(false);
 
+    /**
+     * Tracks the total number of transformers requested from the subscription
+     */
+    private final AtomicInteger transformersRequested = new AtomicInteger(0);
+
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture) {
         this.s3 = s3;
@@ -127,23 +132,41 @@ public void onSubscribe(Subscription s) {
             return;
         }
         this.subscription = s;
-        this.subscription.request(1);
+        request(1);
+    }
+
+    private void request(int amount) {
+        transformersRequested.addAndGet(amount);
+        subscription.request(amount);
     }
 
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        log.info(() -> "onNext");
+        // todo change to trace log
+        log.info(() -> "Total in flight parts: " + inFlightRequests.size()
+                       + ". Total completed parts: " + completedParts + ". Transformers requested: "
+                       + transformersRequested.get() + ". Total pending transformers: "
+                       + pendingTransformers.size() + ". Current in flight requests: " + inFlightRequests);
         if (asyncResponseTransformer == null) {
             subscription.cancel();
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
         }
+        executeRequestOrAddToPending(asyncResponseTransformer);
+    }
 
+    private void executeRequestOrAddToPending(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (handleFirstRequest(asyncResponseTransformer)) {
             return;
         }
 
+        if (inFlightRequests.size() >= MAX_IN_FLIGHT) {
+            pendingTransformers.offer(asyncResponseTransformer);
+            return;
+        }
+
         sendNextRequest(asyncResponseTransformer);
         requestMoreIfNeeded();
+
     }
 
     // Handle first request.
@@ -177,28 +200,36 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             return;
         }
 
-        int partToGet = nextPart();
+        Integer partToGet = nextPart();
+
         GetObjectRequest request = nextRequest(partToGet);
-        log.info(() -> "Sending next request for part: '" + partToGet);
+        // todo change to trace log
+        log.info(() -> "Sending next request for part: " + partToGet);
+
         CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
+
         inFlightRequests.put(partToGet, response);
-        log.info(() -> "Total in flight parts: " + inFlightRequests.size());
+
         response.whenComplete((res, e) -> {
-            log.info(() -> "Completed part: '" + partToGet);
-            inFlightRequests.remove(partToGet);
-            log.info(() -> "Total in flight parts: " + inFlightRequests.size());
+            // Defensive: ensure we only process completion once
+            CompletableFuture<GetObjectResponse> removed = inFlightRequests.remove(partToGet);
+
+            completedParts.incrementAndGet();
             if (e != null) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
+                log.error(() -> "Error on part " + partToGet + ": " + e);
                 resultFuture.completeExceptionally(e);
                 inFlightRequests.values().forEach(future -> future.cancel(true));
                 return;
             }
-            completedParts.incrementAndGet();
             if (completedParts.get() == totalParts) {
+                // todo remove log
+                log.info(() -> "================= ALL PARTS COMPLETED ==================");
                 subscription.cancel();
                 resultFuture.complete(getObjectResponse);
             } else {
+                processPendingTransformers();
                 requestMoreIfNeeded();
             }
         });
@@ -215,7 +246,10 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         CompletableFutureUtils.forwardExceptionTo(resultFuture, responseFuture);
 
         responseFuture.whenComplete((res, e) -> {
-            inFlightRequests.remove(1);
+            // Defensive: ensure we only process completion once
+            CompletableFuture<GetObjectResponse> removed = inFlightRequests.remove(1);
+
+            completedParts.incrementAndGet();
             if (e != null) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
@@ -226,22 +260,24 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             Integer partCount = res.partsCount();
             eTag = res.eTag();
             if (partCount != null && totalParts == null) {
+                // todo change debug log
                 log.info(() -> String.format("Total amount of parts of the object to download: %d", partCount));
                 // MultipartDownloadUtils.multipartDownloadResumeContext(getObjectRequest)
                 //                       .ifPresent(ctx -> ctx.totalParts(partCount));
                 totalParts = partCount;
             }
 
-            completedParts.incrementAndGet();
             // it is a multipart object?
             if (totalParts == null || totalParts == 1) {
                 // Single part object detected, skip multipart and complete everything now
+                // todo change debug log
                 log.info(() -> "Single Part object detected, skipping multipart download");
                 subscription.cancel();
                 resultFuture.complete(res);
                 return;
             }
 
+            // todo change debug log
             log.info(() -> "Multipart object detected, performing multipart download");
             // part 1 already completed, so skip it
             for (int i = 2; i <= totalParts; i++) {
@@ -249,10 +285,8 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             }
             getObjectResponse = res;
 
-            // Process pending transformers
             processPendingTransformers();
-
-            subscription.request(1);
+            requestMoreIfNeeded();
         });
     }
 
@@ -260,16 +294,43 @@ private void processPendingTransformers() {
         synchronized (pendingTransformers) {
             AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = pendingTransformers.poll();
             while (transformer != null) {
-                sendNextRequest(transformer);
+                executeRequestOrAddToPending(transformer);
                 transformer = pendingTransformers.poll();
             }
         }
     }
 
     private void requestMoreIfNeeded() {
-        if (!allPartsCompletedOrInFlights() && inFlightRequests.size() < MAX_IN_FLIGHT) {
-            log.info(() -> "Requesting next part");
-            subscription.request(1);
+        if (totalParts == null) {
+            return; // Don't know total parts yet
+        }
+
+        int currentRequested = transformersRequested.get();
+        if (currentRequested >= totalParts) {
+            return; // Already requested enough transformers
+        }
+
+        // Don't request more if we already have enough work in progress
+        int totalWorkInProgress = inFlightRequests.size() + completedParts.get();
+        if (totalWorkInProgress >= totalParts) {
+            // todo change trace log
+            log.info(() -> "Not requesting more. Total work in progress (" + totalWorkInProgress
+                           + ") >= totalParts (" + totalParts + ")");
+            return;
+        }
+
+        // Only request more if we have capacity and remaining parts
+        int remainingParts = allRemainingParts.size();
+        if (remainingParts > 0 && inFlightRequests.size() < MAX_IN_FLIGHT) {
+            int partsNeeded = Math.min(Math.min(totalParts - currentRequested, remainingParts),
+                                       MAX_IN_FLIGHT - inFlightRequests.size());
+            if (partsNeeded > 0) {
+                // todo change trace log
+                log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
+                               + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
+                               + ". InFlight: " + inFlightRequests.size());
+                request(partsNeeded);
+            }
         }
     }
 
@@ -279,10 +340,6 @@ private Integer nextPart() {
         }
     }
 
-    private boolean allPartsCompletedOrInFlights() {
-        return inFlightRequests.size() + completedParts.get() >= totalParts;
-    }
-
     @Override
     public void onError(Throwable t) {
         // Signal received from the publisher this is subscribed to, in the case of file download, that's
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index f8e5b9f83e73..6a5199e683e3 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -35,8 +35,6 @@
 import java.nio.file.Path;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
@@ -46,6 +44,7 @@
 import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.S3Configuration;
@@ -74,6 +73,13 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
                                      .serviceConfiguration(S3Configuration.builder()
                                                                           .pathStyleAccessEnabled(true)
                                                                           .build())
+                                     .httpClient(NettyNioAsyncHttpClient.builder()
+                                                                        // .maxConcurrency(10_000)
+                                                                        // .connectionAcquisitionTimeout(Duration.ofSeconds(5))
+                                                                        // .connectionTimeout(Duration.ofSeconds(5))
+                                                                        // .connectionTimeToLive(Duration.ofSeconds(5))
+                                                                        .build())
+                                     // .httpClient(AwsCrtAsyncHttpClient.create())
                                      .build();
         util = new MultipartDownloadTestUtil(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
@@ -262,15 +268,70 @@ void errorOnMiddlePart_retryable() {
         verify(exactly(4), getRequestedFor(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey))));
     }
 
+    @Test
+    void errorOnFirstPart_retryable_thenSucceeds() throws Exception {
+        int partSize = 1024;
+        int totalPart = 3;
+        Random random = new Random();
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("Started")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 1</Message></Error>"))
+                    .willSetStateTo("retry1"));
+
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=1", testBucket, testKey)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry1")
+                    .willReturn(aResponse()
+                                    .withStatus(500)
+                                    .withBody("<Error><Code>InternalError</Code><Message>Internal error 2</Message></Error>"))
+                    .willSetStateTo("retry2"));
+
+        byte[] part1Data = new byte[partSize];
+        random.nextBytes(part1Data);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 1)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withHeader("x-amz-mp-parts-count", totalPart + "")
+                                    .withHeader("x-amz-content-range", contentRangeHeader(1, totalPart, partSize))
+                                    .withHeader("ETag", "test-etag")
+                                    .withBody(part1Data)));
+
+        byte[] part2Data = new byte[partSize];
+        random.nextBytes(part2Data);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 2)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withHeader("x-amz-mp-parts-count", totalPart + "")
+                                    .withHeader("x-amz-content-range", contentRangeHeader(2, totalPart, partSize))
+                                    .withHeader("ETag", "test-etag")
+                                    .withBody(part2Data)));
+
+        byte[] part3Data = new byte[partSize];
+        random.nextBytes(part3Data);
+        stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 3)))
+                    .inScenario("retry")
+                    .whenScenarioStateIs("retry2")
+                    .willReturn(aResponse()
+                                    .withHeader("x-amz-mp-parts-count", totalPart + "")
+                                    .withHeader("x-amz-content-range", contentRangeHeader(3, totalPart, partSize))
+                                    .withHeader("ETag", "test-etag")
+                                    .withBody(part3Data)));
+
+
+    }
+
     @Test
     void errorOnMiddlePart_retryable_thenSucceeds() throws Exception {
         int partSize = 1024;
         int totalPart = 3;
-        List<Byte> expectedData = new ArrayList<>();
+        Random random = new Random();
         byte[] part1Data = util.stubForPart(testBucket, testKey, 1, totalPart, partSize);
-        for (byte b: part1Data) {
-            expectedData.add(b);
-        }
 
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=2", testBucket, testKey)))
                     .inScenario("retry")
@@ -298,7 +359,7 @@ void errorOnMiddlePart_retryable_thenSucceeds() throws Exception {
         );
 
         byte[] part2Data = new byte[partSize];
-        new Random().nextBytes(part2Data);
+        random.nextBytes(part2Data);
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 2)))
                     .inScenario("retry")
                     .whenScenarioStateIs("retry3")
@@ -307,15 +368,9 @@ void errorOnMiddlePart_retryable_thenSucceeds() throws Exception {
                                     .withHeader("x-amz-content-range", contentRangeHeader(2, totalPart, partSize))
                                     .withHeader("ETag", "test-etag")
                                     .withBody(part2Data)));
-        for (byte b: part2Data) {
-            expectedData.add(b);
-        }
 
         byte[] part3Data = new byte[partSize];
-        new Random().nextBytes(part3Data);
-        for (byte b: part3Data) {
-            expectedData.add(b);
-        }
+        random.nextBytes(part3Data);
 
         stubFor(get(urlEqualTo(String.format("/%s/%s?partNumber=%d", testBucket, testKey, 3)))
                     .willReturn(aResponse()
@@ -346,12 +401,10 @@ void errorOnMiddlePart_retryable_thenSucceeds() throws Exception {
 
     }
 
-
     @Test
     void veryHighPartCount_shouldSucceed() throws Exception {
-        // 10_000_000 bytes -> 10MB total
-        int numParts = 10_000;
-        int partSize = 1000;
+        int numParts = 5000;
+        int partSize = 100;
 
         byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
 
@@ -361,7 +414,8 @@ void veryHighPartCount_shouldSucceed() throws Exception {
                                                                                     .build(),
                                                                                 AsyncResponseTransformer.toFile(testFile));
 
-        assertThat(response).succeedsWithin(Duration.of(2, ChronoUnit.MINUTES));
+        assertThat(response).succeedsWithin(Duration.of(5, ChronoUnit.MINUTES));
+        response.join();
         byte[] actualBody = Files.readAllBytes(testFile);
         assertThat(actualBody).isEqualTo(expectedBody);
         assertThat(response).isNotNull();

From 0a20a9c4463635f6e931a24bb716808d1672d442 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 4 Sep 2025 11:29:06 -0400
Subject: [PATCH 13/41] TM integration

---
 .../core/async/AsyncResponseTransformer.java  |  2 +-
 ...FileAsyncResponseTransformerPublisher.java |  5 +-
 .../s3/internal/GenericS3TransferManager.java |  2 +-
 .../progress/TransferProgressUpdater.java     | 90 ++++++++++++++++---
 .../multipart/DownloadObjectHelper.java       | 12 +--
 .../MultipartConfigurationResolver.java       |  7 ++
 .../multipart/MultipartS3AsyncClient.java     |  3 +-
 ...onLinearMultipartDownloaderSubscriber.java | 42 ++++++---
 .../s3/multipart/MultipartConfiguration.java  | 32 +++++++
 9 files changed, 158 insertions(+), 37 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
index 44a704f30d10..7db9a2a740c4 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
@@ -392,7 +392,7 @@ interface Builder<ResponseT, ResultT>
 
             /**
              * If the AsyncResponseTransformers returned by the {@link SplitResult#publisher()} support concurrent
-             * parallel streaming of multiple content body concurrently
+             * parallel streaming of multiple content body concurrently.
              * @return
              */
             Boolean supportsNonSerial();
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 840c22b2ebf3..013e11ca0c64 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -60,6 +60,9 @@ public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> res
 
     @Override
     public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
+        if (s == null) {
+            throw new NullPointerException("Subscription must not be null");
+        }
         this.subscriber = s;
         s.onSubscribe(new ThreadSafeEmittingSubscription<>(
             s, new AtomicLong(0), () -> {}, new AtomicBoolean(), log, this::createTransformer));
@@ -83,7 +86,7 @@ private AsyncResponseTransformer<T, T> createTransformer() {
      * transformer will retry independently based on the retry configuration of the client it is used with. We only need to verify
      * the completion state of the future of each individually
      */
-    class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
+    private class IndividualFileTransformer implements AsyncResponseTransformer<T, T> {
         private AsyncResponseTransformer<T, T> delegate;
         private CompletableFuture<T> future;
 
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
index 29bcdc34d93f..afe397e269e8 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
@@ -395,7 +395,7 @@ private TransferProgressUpdater doDownloadFile(
         try {
             progressUpdater.transferInitiated();
             responseTransformer = isS3ClientMultipartEnabled()
-                                  ? progressUpdater.wrapResponseTransformerForMultipartDownload(
+                                  ? progressUpdater.wrapForNonSerialFileDownload(
                 responseTransformer, downloadRequest.getObjectRequest())
                                   : progressUpdater.wrapResponseTransformer(responseTransformer);
             progressUpdater.registerCompletion(returnFuture);
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
index aaf1ee84a9ad..4d78530a45ce 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/progress/TransferProgressUpdater.java
@@ -22,8 +22,10 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.reactivestreams.Subscriber;
 import software.amazon.awssdk.annotations.SdkInternalApi;
+import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncRequestBody;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
 import software.amazon.awssdk.core.async.listener.AsyncRequestBodyListener;
 import software.amazon.awssdk.core.async.listener.AsyncResponseTransformerListener;
 import software.amazon.awssdk.core.async.listener.PublisherListener;
@@ -173,25 +175,85 @@ public <ResultT> AsyncResponseTransformer<GetObjectResponse, ResultT> wrapRespon
             new BaseAsyncResponseTransformerListener() {
                 @Override
                 public void transformerOnResponse(GetObjectResponse response) {
-                    // if the GetObjectRequest is a range-get, the Content-Length headers of the response needs to be used
-                    // to update progress since the Content-Range would incorrectly upgrade progress with the whole object
-                    // size.
-                    if (request.range() != null) {
-                        if (response.contentLength() != null) {
-                            progress.updateAndGet(b -> b.totalBytes(response.contentLength()).sdkResponse(response));
-                        }
-                    } else {
-                        // if the GetObjectRequest is not a range-get, it might be a part-get. In that case, we need to parse
-                        // the Content-Range header to get the correct totalByte amount.
-                        ContentRangeParser
-                            .totalBytes(response.contentRange())
-                            .ifPresent(totalBytes -> progress.updateAndGet(b -> b.totalBytes(totalBytes).sdkResponse(response)));
-                    }
+                    multipartDownloadOnResponse(request, response);
                 }
             }
         );
     }
 
+    private void multipartDownloadOnResponse(GetObjectRequest request, GetObjectResponse response) {
+        // if the GetObjectRequest is a range-get, the Content-Length headers of the response needs to be used
+        // to update progress since the Content-Range would incorrectly upgrade progress with the whole object
+        // size.
+        if (request.range() != null) {
+            if (response.contentLength() != null) {
+                progress.updateAndGet(b -> b.totalBytes(response.contentLength()).sdkResponse(response));
+            }
+        } else {
+            // if the GetObjectRequest is not a range-get, it might be a part-get. In that case, we need to parse
+            // the Content-Range header to get the correct totalByte amount.
+            ContentRangeParser
+                .totalBytes(response.contentRange())
+                .ifPresent(totalBytes -> progress.updateAndGet(b -> b.totalBytes(totalBytes).sdkResponse(response)));
+        }
+    }
+
+    // upstream transformer
+    public <ResultT> AsyncResponseTransformer<GetObjectResponse, ResultT> wrapForNonSerialFileDownload(
+        AsyncResponseTransformer<GetObjectResponse, ResultT> responseTransformer, GetObjectRequest request) {
+        return new AsyncResponseTransformer<GetObjectResponse, ResultT>() {
+            @Override
+            public CompletableFuture<ResultT> prepare() {
+                return responseTransformer.prepare();
+            }
+
+            @Override
+            public void onResponse(GetObjectResponse response) {
+                responseTransformer.onResponse(response);
+            }
+
+            @Override
+            public void onStream(SdkPublisher<ByteBuffer> publisher) {
+                responseTransformer.onStream(publisher);
+            }
+
+            @Override
+            public void exceptionOccurred(Throwable error) {
+                responseTransformer.exceptionOccurred(error);
+            }
+
+            @Override
+            public SplitResult<GetObjectResponse, ResultT> split(SplittingTransformerConfiguration splitConfig) {
+                return responseTransformer
+                    .split(splitConfig)
+                    .copy(b -> b.publisher(wrapIndividualTransformer(b.publisher(), request)));
+            }
+
+            @Override
+            public String name() {
+                return responseTransformer.name();
+            }
+        };
+    }
+
+    private <ResultT> SdkPublisher<AsyncResponseTransformer<GetObjectResponse, ResultT>> wrapIndividualTransformer(
+        SdkPublisher<AsyncResponseTransformer<GetObjectResponse, ResultT>> publisher, GetObjectRequest request) {
+        // each of the individual transformer for multipart file download
+        return publisher.map(art -> AsyncResponseTransformerListener.wrap(
+                art,
+                new AsyncResponseTransformerListener<GetObjectResponse>() {
+                    @Override
+                    public void transformerOnResponse(GetObjectResponse response) {
+                        multipartDownloadOnResponse(request, response);
+                    }
+
+                    @Override
+                    public void subscriberOnNext(ByteBuffer byteBuffer) {
+                        incrementBytesTransferred(byteBuffer.limit());
+                    }
+                }));
+    }
+
     public <ResultT> AsyncResponseTransformer<GetObjectResponse, ResultT> wrapResponseTransformer(
         AsyncResponseTransformer<GetObjectResponse, ResultT> responseTransformer) {
         return AsyncResponseTransformerListener.wrap(
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index e313bf9917c5..868b32babaf8 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -31,10 +31,12 @@ public class DownloadObjectHelper {
 
     private final S3AsyncClient s3AsyncClient;
     private final long bufferSizeInBytes;
+    private final long maxInFlight;
 
-    public DownloadObjectHelper(S3AsyncClient s3AsyncClient, long bufferSizeInBytes) {
+    public DownloadObjectHelper(S3AsyncClient s3AsyncClient, long bufferSizeInBytes, int maxInFlight) {
         this.s3AsyncClient = s3AsyncClient;
         this.bufferSizeInBytes = bufferSizeInBytes;
+        this.maxInFlight = maxInFlight;
     }
 
     public <T> CompletableFuture<T> downloadObject(
@@ -51,17 +53,17 @@ public <T> CompletableFuture<T> downloadObject(
             return downloadPartsSerially(getObjectRequest, split);
         }
 
-        log.info(() -> "================= USING downloadPartsNonLinear ==================");
-        return downloadPartsNonSerially(getObjectRequest, split);
+        return downloadPartsNonSerially(getObjectRequest, split, maxInFlight);
 
     }
 
     private <T> CompletableFuture<T> downloadPartsNonSerially(
         GetObjectRequest getObjectRequest,
-        AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split) {
+        AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split,
+        int maxInFlight) {
         // TODO pause & resume
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
-            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture());
+            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture(), maxInFlight);
         split.publisher().subscribe(subscriber);
         return split.resultFuture();
     }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
index 9fc199175bda..c63a66bb672e 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
@@ -26,9 +26,11 @@
 public final class MultipartConfigurationResolver {
 
     private static final long DEFAULT_MIN_PART_SIZE = 8L * 1024 * 1024;
+    private static final int DEFAULT_MAX_IN_FLIGHT = 50;
     private final long minimalPartSizeInBytes;
     private final long apiCallBufferSize;
     private final long thresholdInBytes;
+    private final int maxInFlight;
 
     public MultipartConfigurationResolver(MultipartConfiguration multipartConfiguration) {
         Validate.notNull(multipartConfiguration, "multipartConfiguration");
@@ -37,6 +39,7 @@ public MultipartConfigurationResolver(MultipartConfiguration multipartConfigurat
         this.apiCallBufferSize = Validate.getOrDefault(multipartConfiguration.apiCallBufferSizeInBytes(),
                                                        () -> minimalPartSizeInBytes * 4);
         this.thresholdInBytes = Validate.getOrDefault(multipartConfiguration.thresholdInBytes(), () -> minimalPartSizeInBytes);
+        this.maxInFlight = Validate.getOrDefault(multipartConfiguration.maxInflightDownloads(), () -> DEFAULT_MAX_IN_FLIGHT);
     }
 
     public long minimalPartSizeInBytes() {
@@ -50,4 +53,8 @@ public long thresholdInBytes() {
     public long apiCallBufferSize() {
         return apiCallBufferSize;
     }
+
+    public int maxInFlight() {
+        return maxInFlight;
+    }
 }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
index 6142db7772f7..3ba362ccae55 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
@@ -63,9 +63,10 @@ private MultipartS3AsyncClient(S3AsyncClient delegate, MultipartConfiguration mu
         long minPartSizeInBytes = resolver.minimalPartSizeInBytes();
         long threshold = resolver.thresholdInBytes();
         long apiCallBufferSize = resolver.apiCallBufferSize();
+        int maxInFLight = resolver.maxInFlight();
         mpuHelper = new UploadObjectHelper(delegate, resolver);
         copyObjectHelper = new CopyObjectHelper(delegate, minPartSizeInBytes, threshold);
-        downloadObjectHelper = new DownloadObjectHelper(delegate, apiCallBufferSize);
+        downloadObjectHelper = new DownloadObjectHelper(delegate, apiCallBufferSize, maxInFLight);
         this.checksumEnabled = checksumEnabled;
     }
 
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index af38b4bb131b..4ec2ea60f8a6 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -37,7 +37,9 @@
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
     private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
-    private static final int MAX_IN_FLIGHT = 50;
+    // private static final int MAX_IN_FLIGHT = 50;
+
+    private final int maxInFlight;
 
     /**
      * The s3 client used to make the individual part requests
@@ -118,11 +120,14 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicInteger transformersRequested = new AtomicInteger(0);
 
-    public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3, GetObjectRequest getObjectRequest,
-                                                  CompletableFuture<GetObjectResponse> resultFuture) {
+    public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
+                                                  GetObjectRequest getObjectRequest,
+                                                  CompletableFuture<GetObjectResponse> resultFuture,
+                                                  int maxInFLight) {
         this.s3 = s3;
         this.getObjectRequest = getObjectRequest;
         this.resultFuture = resultFuture;
+        this.maxInFlight = maxInFLight;
     }
 
     @Override
@@ -159,7 +164,7 @@ private void executeRequestOrAddToPending(AsyncResponseTransformer<GetObjectResp
             return;
         }
 
-        if (inFlightRequests.size() >= MAX_IN_FLIGHT) {
+        if (inFlightRequests.size() >= maxInFlight) {
             pendingTransformers.offer(asyncResponseTransformer);
             return;
         }
@@ -321,17 +326,24 @@ private void requestMoreIfNeeded() {
 
         // Only request more if we have capacity and remaining parts
         int remainingParts = allRemainingParts.size();
-        if (remainingParts > 0 && inFlightRequests.size() < MAX_IN_FLIGHT) {
-            int partsNeeded = Math.min(Math.min(totalParts - currentRequested, remainingParts),
-                                       MAX_IN_FLIGHT - inFlightRequests.size());
-            if (partsNeeded > 0) {
-                // todo change trace log
-                log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
-                               + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
-                               + ". InFlight: " + inFlightRequests.size());
-                request(partsNeeded);
-            }
+        if (remainingParts == 0) {
+            return;
+        }
+
+        if (inFlightRequests.size() >= maxInFlight) {
+            return;
         }
+
+        int partsNeeded = Math.min(Math.min(totalParts - currentRequested, remainingParts),
+                                   maxInFlight- inFlightRequests.size());
+        if (partsNeeded > 0) {
+            // todo change trace log
+            log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
+                           + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
+                           + ". InFlight: " + inFlightRequests.size());
+            request(partsNeeded);
+        }
+
     }
 
     private Integer nextPart() {
@@ -345,6 +357,8 @@ public void onError(Throwable t) {
         // Signal received from the publisher this is subscribed to, in the case of file download, that's
         // FileAsyncResponseTransformerPublisher.
         // failed state, something really wrong has happened, cancel everything
+        inFlightRequests.values().forEach(future -> future.cancel(true));
+        inFlightRequests.clear();
         resultFuture.completeExceptionally(t);
     }
 
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
index 9b074d6244f3..d586afdaa8a2 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
@@ -44,11 +44,13 @@ public final class MultipartConfiguration implements ToCopyableBuilder<Multipart
     private final Long thresholdInBytes;
     private final Long minimumPartSizeInBytes;
     private final Long apiCallBufferSizeInBytes;
+    private final Integer maxInflightDownloads;
 
     private MultipartConfiguration(DefaultMultipartConfigBuilder builder) {
         this.thresholdInBytes = builder.thresholdInBytes;
         this.minimumPartSizeInBytes = builder.minimumPartSizeInBytes;
         this.apiCallBufferSizeInBytes = builder.apiCallBufferSizeInBytes;
+        this.maxInflightDownloads = builder.maxInflightDownloads;
     }
 
     public static Builder builder() {
@@ -89,6 +91,10 @@ public Long apiCallBufferSizeInBytes() {
         return this.apiCallBufferSizeInBytes;
     }
 
+    public Integer maxInflightDownloads() {
+        return this.maxInflightDownloads;
+    }
+
     /**
      * Builder for a {@link MultipartConfiguration}.
      */
@@ -163,12 +169,27 @@ public interface Builder extends CopyableBuilder<Builder, MultipartConfiguration
          * @return the value of the maximum memory usage.
          */
         Long apiCallBufferSizeInBytes();
+
+        /**
+         * todo
+         * @param maxInflightDownloads
+         * @return
+         */
+        Builder maxInflightDownloads(Integer maxInflightDownloads);
+
+        /**
+         * todo
+         * @return
+         */
+        Integer maxInflightDownloads();
+
     }
 
     private static class DefaultMultipartConfigBuilder implements Builder {
         private Long thresholdInBytes;
         private Long minimumPartSizeInBytes;
         private Long apiCallBufferSizeInBytes;
+        private Integer maxInflightDownloads;
 
         public Builder thresholdInBytes(Long thresholdInBytes) {
             this.thresholdInBytes = thresholdInBytes;
@@ -188,6 +209,17 @@ public Long minimumPartSizeInBytes() {
             return this.minimumPartSizeInBytes;
         }
 
+        @Override
+        public Builder maxInflightDownloads(Integer maxInflightDownloads) {
+            this.maxInflightDownloads = maxInflightDownloads;
+            return this;
+        }
+
+        @Override
+        public Integer maxInflightDownloads() {
+            return this.maxInflightDownloads;
+        }
+
         @Override
         public Builder apiCallBufferSizeInBytes(Long maximumMemoryUsageInBytes) {
             this.apiCallBufferSizeInBytes = maximumMemoryUsageInBytes;

From e1aebb5f81c5d745ae3b8bf3edf58243222e4cd8 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 4 Sep 2025 11:35:44 -0400
Subject: [PATCH 14/41] fix tests

---
 .../multipart/DownloadObjectHelper.java       |  2 +-
 ...ipartDownloaderSubscriberWiremockTest.java | 34 +++++++++++--------
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 868b32babaf8..6cd19da3de1a 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -31,7 +31,7 @@ public class DownloadObjectHelper {
 
     private final S3AsyncClient s3AsyncClient;
     private final long bufferSizeInBytes;
-    private final long maxInFlight;
+    private final int maxInFlight;
 
     public DownloadObjectHelper(S3AsyncClient s3AsyncClient, long bufferSizeInBytes, int maxInFlight) {
         this.s3AsyncClient = s3AsyncClient;
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
index ca9d4656c2f1..d44d40011987 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
@@ -29,6 +29,8 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.reactivestreams.Subscriber;
 import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
@@ -72,9 +74,9 @@ void tearDown() throws Exception {
         fileSystem.close();
     }
 
-    @Test
-    void happyPath_multipartDownload() throws Exception {
-        int numParts = 4;
+    @ParameterizedTest
+    @ValueSource(ints = {2, 3, 4, 5, 6, 7, 8, 9, 10})
+    void happyPath_multipartDownload(int numParts) throws Exception {
         int partSize = 1024;
         byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
 
@@ -85,13 +87,14 @@ void happyPath_multipartDownload() throws Exception {
                                              .build());
 
         CompletableFuture<GetObjectResponse> resultFuture = new CompletableFuture<>();
-        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber = 
+        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber =
             new NonLinearMultipartDownloaderSubscriber(s3AsyncClient,
-                                                      GetObjectRequest.builder()
-                                                                      .bucket(testBucket)
-                                                                      .key(testKey)
-                                                                      .build(),
-                                                      resultFuture);
+                                                       GetObjectRequest.builder()
+                                                                       .bucket(testBucket)
+                                                                       .key(testKey)
+                                                                       .build(),
+                                                       resultFuture,
+                                                       50);
 
         split.publisher().subscribe(subscriber);
         GetObjectResponse getObjectResponse = resultFuture.join();
@@ -115,13 +118,14 @@ void singlePartObject_shouldCompleteWithoutMultipart() throws Exception {
                                              .build());
 
         CompletableFuture<GetObjectResponse> resultFuture = new CompletableFuture<>();
-        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber = 
+        Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> subscriber =
             new NonLinearMultipartDownloaderSubscriber(s3AsyncClient,
-                                                      GetObjectRequest.builder()
-                                                                      .bucket(testBucket)
-                                                                      .key(testKey)
-                                                                      .build(),
-                                                      resultFuture);
+                                                       GetObjectRequest.builder()
+                                                                       .bucket(testBucket)
+                                                                       .key(testKey)
+                                                                       .build(),
+                                                       resultFuture,
+                                                       50);
 
         split.publisher().subscribe(subscriber);
         GetObjectResponse getObjectResponse = resultFuture.join();

From 3a0a0b14305c0233900361c718fc1238d2870103 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 4 Sep 2025 15:27:15 -0400
Subject: [PATCH 15/41] debugging for long stop before completing future

---
 ...FileAsyncResponseTransformerPublisher.java |   7 +-
 ...partClientFileDownloadIntegrationTest.java | 126 ++++++++++++++++++
 .../multipart/DownloadObjectHelper.java       |   5 +-
 ...onLinearMultipartDownloaderSubscriber.java |  23 ++--
 4 files changed, 149 insertions(+), 12 deletions(-)
 create mode 100644 services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 013e11ca0c64..7497167f9504 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -65,7 +65,12 @@ public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
         }
         this.subscriber = s;
         s.onSubscribe(new ThreadSafeEmittingSubscription<>(
-            s, new AtomicLong(0), () -> {}, new AtomicBoolean(), log, this::createTransformer));
+            s,
+            new AtomicLong(0),
+            () -> log.info(() -> "received onCancel (do nothing)"),
+            new AtomicBoolean(),
+            log,
+            this::createTransformer));
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
diff --git a/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
new file mode 100644
index 000000000000..d819d53e6fa6
--- /dev/null
+++ b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.multipart;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static software.amazon.awssdk.testutils.service.S3BucketUtils.temporaryBucketName;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import software.amazon.awssdk.core.FileTransformerConfiguration;
+import software.amazon.awssdk.core.ResponseBytes;
+import software.amazon.awssdk.core.SdkRequest;
+import software.amazon.awssdk.core.async.AsyncRequestBody;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.interceptor.Context;
+import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
+import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.S3IntegrationTestBase;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.testutils.RandomTempFile;
+import software.amazon.awssdk.utils.JavaSystemSetting;
+import software.amazon.awssdk.utils.Logger;
+
+@Timeout(value = 10, unit = TimeUnit.MINUTES)
+public class S3MultipartClientFileDownloadIntegrationTest extends S3IntegrationTestBase {
+    private static final Logger log = Logger.loggerFor(S3MultipartClientFileDownloadIntegrationTest.class);
+    private static final int MIB = 1024 * 1024;
+    private static final String TEST_BUCKET = temporaryBucketName(S3MultipartClientFileDownloadIntegrationTest.class);
+    private static final String TEST_KEY = "testfile.dat";
+    private static final int OBJ_SIZE = 200 * MIB;
+    private static final long PART_SIZE = 5 * MIB;
+
+    private static RandomTempFile localFile;
+    private S3AsyncClient s3Client;
+    private TestInterceptor interceptor;
+
+    @BeforeAll
+    public static void setup() throws Exception {
+        log.info(() -> "setup");
+        setUp();
+        log.info(() -> "create bucket");
+        createBucket(TEST_BUCKET);
+        localFile = new RandomTempFile(TEST_KEY, OBJ_SIZE);
+        localFile.deleteOnExit();
+        S3AsyncClient s3Client = S3AsyncClient.builder()
+                                              .multipartEnabled(true)
+                                              .multipartConfiguration(c -> c.minimumPartSizeInBytes(PART_SIZE))
+                                              .credentialsProvider(CREDENTIALS_PROVIDER_CHAIN)
+                                              .build();
+        log.info(() -> "put multipart object");
+        s3Client.putObject(r -> r.bucket(TEST_BUCKET).key(TEST_KEY), AsyncRequestBody.fromFile(localFile))
+                .join();
+        s3.close();
+    }
+
+    @BeforeEach
+    public void init() {
+        log.info(() -> "Initializing S3MultipartClientFileDownloadIntegrationTest");
+        this.interceptor = new TestInterceptor();
+        this.s3Client = S3AsyncClient.builder()
+                                     .multipartEnabled(true)
+                                     .multipartConfiguration(c -> c.maxInflightDownloads(5))
+                                     .overrideConfiguration(o -> o.addExecutionInterceptor(this.interceptor))
+                                     .credentialsProvider(CREDENTIALS_PROVIDER_CHAIN)
+                                     .build();
+    }
+
+    @Test
+    void download_defaultCreateNewFile_shouldSucceed() {
+        Path path = tmpPath().resolve(UUID.randomUUID().toString());
+        CompletableFuture<GetObjectResponse> future = s3Client.getObject(
+            req -> req.bucket(TEST_BUCKET).key(TEST_KEY),
+            AsyncResponseTransformer.toFile(path, FileTransformerConfiguration.defaultCreateNew()));
+        future.join();
+        assertThat(path.toFile()).hasSameBinaryContentAs(localFile);
+        assertThat(interceptor.parts.size()).isEqualTo(OBJ_SIZE / PART_SIZE);
+        log.info(() -> "All parts intercepted`: " + interceptor.parts.toString());
+        path.toFile().delete();
+    }
+
+    private Path tmpPath() {
+        return Paths.get(JavaSystemSetting.TEMP_DIRECTORY.getStringValueOrThrow());
+    }
+
+    private static final class TestInterceptor implements ExecutionInterceptor {
+        List<Integer> parts = new ArrayList<>();
+
+        @Override
+        public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttributes executionAttributes) {
+            SdkRequest request = context.request();
+            if (request instanceof GetObjectRequest) {
+                log.info(() -> "Received GetObjectRequest for request " + request);
+                GetObjectRequest getObjectRequest = (GetObjectRequest) request;
+                parts.add(getObjectRequest.partNumber());
+            } else {
+                log.warn(() -> "Unexpected request type: " + request.getClass());
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 6cd19da3de1a..768bfe4d9bf6 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -62,10 +62,11 @@ private <T> CompletableFuture<T> downloadPartsNonSerially(
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split,
         int maxInFlight) {
         // TODO pause & resume
+        CompletableFuture<T> returnFuture = split.resultFuture();
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
-            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture(), maxInFlight);
+            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) returnFuture, maxInFlight);
         split.publisher().subscribe(subscriber);
-        return split.resultFuture();
+        return returnFuture;
     }
 
     private <T> CompletableFuture<T> downloadPartsSerially(GetObjectRequest getObjectRequest,
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 4ec2ea60f8a6..4289ac760d72 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -37,8 +37,10 @@
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
     private static final Logger log = Logger.loggerFor(NonLinearMultipartDownloaderSubscriber.class);
-    // private static final int MAX_IN_FLIGHT = 50;
 
+    /**
+     * Maximum number of concurrent GetObject requests
+     */
     private final int maxInFlight;
 
     /**
@@ -148,10 +150,11 @@ private void request(int amount) {
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         // todo change to trace log
-        log.info(() -> "Total in flight parts: " + inFlightRequests.size()
-                       + ". Total completed parts: " + completedParts + ". Transformers requested: "
-                       + transformersRequested.get() + ". Total pending transformers: "
-                       + pendingTransformers.size() + ". Current in flight requests: " + inFlightRequests);
+        log.info(() -> "\nTotal in flight parts: " + inFlightRequests.size()
+                       + "\nTotal completed parts: " + completedParts
+                       + "\nTransformers requested: " + transformersRequested.get()
+                       + "\nTotal pending transformers: " + pendingTransformers.size()
+                       + "\nCurrent in flight requests: " + inFlightRequests.keySet());
         if (asyncResponseTransformer == null) {
             subscription.cancel();
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
@@ -216,8 +219,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         inFlightRequests.put(partToGet, response);
 
         response.whenComplete((res, e) -> {
-            // Defensive: ensure we only process completion once
-            CompletableFuture<GetObjectResponse> removed = inFlightRequests.remove(partToGet);
+            inFlightRequests.remove(partToGet);
 
             completedParts.incrementAndGet();
             if (e != null) {
@@ -231,8 +233,12 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             if (completedParts.get() == totalParts) {
                 // todo remove log
                 log.info(() -> "================= ALL PARTS COMPLETED ==================");
+                log.info(() -> "remaining in flight (should be empty): " + inFlightRequests.keySet().toString());
+                log.info(() -> "calling cancel");
                 subscription.cancel();
+                log.info(() -> "completing future");
                 resultFuture.complete(getObjectResponse);
+                log.info(() -> "all done in NonLinearMultipartDownloaderSubscriber");
             } else {
                 processPendingTransformers();
                 requestMoreIfNeeded();
@@ -251,8 +257,7 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         CompletableFutureUtils.forwardExceptionTo(resultFuture, responseFuture);
 
         responseFuture.whenComplete((res, e) -> {
-            // Defensive: ensure we only process completion once
-            CompletableFuture<GetObjectResponse> removed = inFlightRequests.remove(1);
+           inFlightRequests.remove(1);
 
             completedParts.incrementAndGet();
             if (e != null) {

From 2f3a14e94f0a1d7195fa733755571d03a302ebd6 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 9 Sep 2025 12:07:21 -0400
Subject: [PATCH 16/41] added outstanding demand tracking, assert with checksum
 in integ test

---
 .../async/FileAsyncResponseTransformer.java   |  6 ++--
 ...partClientFileDownloadIntegrationTest.java | 29 +++++++++++++------
 .../multipart/DownloadObjectHelper.java       |  5 ++--
 ...onLinearMultipartDownloaderSubscriber.java | 23 ++++++++++++---
 4 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index f827589aabeb..07d631030a4f 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -77,15 +77,15 @@ private FileAsyncResponseTransformer(Path path, FileTransformerConfiguration fil
         this.position = position;
     }
 
-    public FileTransformerConfiguration config() {
+    FileTransformerConfiguration config() {
         return configuration.toBuilder().build();
     }
 
-    public Path path() {
+    Path path() {
         return path;
     }
 
-    public Long initialPosition() {
+    Long initialPosition() {
         return position;
     }
 
diff --git a/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
index d819d53e6fa6..a9fced5873f2 100644
--- a/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
+++ b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
@@ -18,20 +18,22 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static software.amazon.awssdk.testutils.service.S3BucketUtils.temporaryBucketName;
 
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
-import org.junit.jupiter.api.AfterAll;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 import software.amazon.awssdk.core.FileTransformerConfiguration;
-import software.amazon.awssdk.core.ResponseBytes;
 import software.amazon.awssdk.core.SdkRequest;
 import software.amazon.awssdk.core.async.AsyncRequestBody;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
@@ -47,13 +49,13 @@
 import software.amazon.awssdk.utils.JavaSystemSetting;
 import software.amazon.awssdk.utils.Logger;
 
-@Timeout(value = 10, unit = TimeUnit.MINUTES)
+@Timeout(value = 5, unit = TimeUnit.MINUTES)
 public class S3MultipartClientFileDownloadIntegrationTest extends S3IntegrationTestBase {
     private static final Logger log = Logger.loggerFor(S3MultipartClientFileDownloadIntegrationTest.class);
     private static final int MIB = 1024 * 1024;
     private static final String TEST_BUCKET = temporaryBucketName(S3MultipartClientFileDownloadIntegrationTest.class);
     private static final String TEST_KEY = "testfile.dat";
-    private static final int OBJ_SIZE = 200 * MIB;
+    private static final int OBJ_SIZE = 100 * MIB;
     private static final long PART_SIZE = 5 * MIB;
 
     private static RandomTempFile localFile;
@@ -85,22 +87,23 @@ public void init() {
         this.interceptor = new TestInterceptor();
         this.s3Client = S3AsyncClient.builder()
                                      .multipartEnabled(true)
-                                     .multipartConfiguration(c -> c.maxInflightDownloads(5))
+                                     .multipartConfiguration(c -> c.maxInflightDownloads(50))
                                      .overrideConfiguration(o -> o.addExecutionInterceptor(this.interceptor))
                                      .credentialsProvider(CREDENTIALS_PROVIDER_CHAIN)
                                      .build();
     }
 
     @Test
-    void download_defaultCreateNewFile_shouldSucceed() {
+    void download_defaultCreateNewFile_shouldSucceed() throws Exception {
         Path path = tmpPath().resolve(UUID.randomUUID().toString());
         CompletableFuture<GetObjectResponse> future = s3Client.getObject(
             req -> req.bucket(TEST_BUCKET).key(TEST_KEY),
             AsyncResponseTransformer.toFile(path, FileTransformerConfiguration.defaultCreateNew()));
         future.join();
-        assertThat(path.toFile()).hasSameBinaryContentAs(localFile);
-        assertThat(interceptor.parts.size()).isEqualTo(OBJ_SIZE / PART_SIZE);
-        log.info(() -> "All parts intercepted`: " + interceptor.parts.toString());
+        assertSameContentWithChecksum(path);
+        int totalParts = OBJ_SIZE / (int) PART_SIZE;
+        assertThat(interceptor.parts.size()).isEqualTo(totalParts);
+        assertThat(interceptor.parts).hasSameElementsAs(IntStream.range(1, totalParts +1).boxed().collect(Collectors.toList()));
         path.toFile().delete();
     }
 
@@ -123,4 +126,12 @@ public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttr
             }
         }
     }
+
+    private void assertSameContentWithChecksum(Path path) throws Exception {
+        MessageDigest md = MessageDigest.getInstance("SHA-256");
+        byte[] downloadedHash = md.digest(Files.readAllBytes(path));
+        md.reset();
+        byte[] originalHash = md.digest(Files.readAllBytes(localFile.toPath()));
+        assertThat(downloadedHash).isEqualTo(originalHash);
+    }
 }
\ No newline at end of file
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 768bfe4d9bf6..6cd19da3de1a 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -62,11 +62,10 @@ private <T> CompletableFuture<T> downloadPartsNonSerially(
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split,
         int maxInFlight) {
         // TODO pause & resume
-        CompletableFuture<T> returnFuture = split.resultFuture();
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
-            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) returnFuture, maxInFlight);
+            s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture(), maxInFlight);
         split.publisher().subscribe(subscriber);
-        return returnFuture;
+        return split.resultFuture();
     }
 
     private <T> CompletableFuture<T> downloadPartsSerially(GetObjectRequest getObjectRequest,
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 4289ac760d72..1a9ec9a395fd 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -122,6 +122,11 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicInteger transformersRequested = new AtomicInteger(0);
 
+    /**
+     * Amount of demand requested but not yet fulfilled by the subscription
+     */
+    private final AtomicInteger outstandingDemand = new AtomicInteger(0);
+
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
                                                   GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture,
@@ -143,6 +148,7 @@ public void onSubscribe(Subscription s) {
     }
 
     private void request(int amount) {
+        outstandingDemand.addAndGet(amount);
         transformersRequested.addAndGet(amount);
         subscription.request(amount);
     }
@@ -150,9 +156,11 @@ private void request(int amount) {
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         // todo change to trace log
-        log.info(() -> "\nTotal in flight parts: " + inFlightRequests.size()
+        outstandingDemand.decrementAndGet();
+        log.info(() -> "=== On Next ===\nTotal in flight parts: " + inFlightRequests.size()
+                       + "\nOutstanding Demand : " + outstandingDemand.get()
                        + "\nTotal completed parts: " + completedParts
-                       + "\nTransformers requested: " + transformersRequested.get()
+                       + "\nTotal transformers requested: " + transformersRequested.get()
                        + "\nTotal pending transformers: " + pendingTransformers.size()
                        + "\nCurrent in flight requests: " + inFlightRequests.keySet());
         if (asyncResponseTransformer == null) {
@@ -219,6 +227,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         inFlightRequests.put(partToGet, response);
 
         response.whenComplete((res, e) -> {
+            log.info(() -> "Completed part: " + partToGet);
             inFlightRequests.remove(partToGet);
 
             completedParts.incrementAndGet();
@@ -230,7 +239,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
                 inFlightRequests.values().forEach(future -> future.cancel(true));
                 return;
             }
-            if (completedParts.get() == totalParts) {
+            if (completedParts.get() >= totalParts) {
                 // todo remove log
                 log.info(() -> "================= ALL PARTS COMPLETED ==================");
                 log.info(() -> "remaining in flight (should be empty): " + inFlightRequests.keySet().toString());
@@ -335,12 +344,18 @@ private void requestMoreIfNeeded() {
             return;
         }
 
+        // don't request if we already have enough work in progress
         if (inFlightRequests.size() >= maxInFlight) {
             return;
         }
 
+        // don't request if we have already requested more work than we can handle
+        if (outstandingDemand.get() >= maxInFlight) {
+            return;
+        }
+
         int partsNeeded = Math.min(Math.min(totalParts - currentRequested, remainingParts),
-                                   maxInFlight- inFlightRequests.size());
+                                   maxInFlight - inFlightRequests.size());
         if (partsNeeded > 0) {
             // todo change trace log
             log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "

From aa0caf1c61936d2d98cb97fc8bdda8c896d33e69 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 11 Sep 2025 14:25:14 -0400
Subject: [PATCH 17/41] Fix pendingTransformer polling

---
 ...ltAsyncResponseTransformerSplitResult.java |  7 ++-
 ...FileAsyncResponseTransformerPublisher.java | 14 ++++-
 .../async/ThreadSafeEmittingSubscription.java |  5 +-
 ...ncResponseTransformerPublisherTckTest.java | 60 +++++++++++++++++++
 ...onLinearMultipartDownloaderSubscriber.java | 12 ++--
 5 files changed, 86 insertions(+), 12 deletions(-)
 create mode 100644 core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
index ec9f56e892ec..8accd9355f85 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
@@ -72,7 +72,7 @@ public static class DefaultBuilder<ResponseT, ResultT>
         implements AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> {
         private SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
         private CompletableFuture<ResultT> future;
-        private Boolean suppressParallelism;
+        private Boolean supportsNonSerial;
 
         DefaultBuilder() {
         }
@@ -80,6 +80,7 @@ public static class DefaultBuilder<ResponseT, ResultT>
         DefaultBuilder(DefaultAsyncResponseTransformerSplitResult<ResponseT, ResultT> split) {
             this.publisher = split.publisher;
             this.future = split.future;
+            this.supportsNonSerial = split.supportsNonSerial;
         }
 
         @Override
@@ -108,13 +109,13 @@ public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> resultFu
 
         @Override
         public Boolean supportsNonSerial() {
-            return suppressParallelism;
+            return supportsNonSerial;
         }
 
         @Override
         public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> supportsNonSerial(
             Boolean supportsParallel) {
-            this.suppressParallelism = supportsParallel;
+            this.supportsNonSerial = supportsParallel;
             return this;
         }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 7497167f9504..752e468d7e59 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -67,7 +67,7 @@ public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
         s.onSubscribe(new ThreadSafeEmittingSubscription<>(
             s,
             new AtomicLong(0),
-            () -> log.info(() -> "received onCancel (do nothing)"),
+            this::onCancel,
             new AtomicBoolean(),
             log,
             this::createTransformer));
@@ -77,6 +77,10 @@ private AsyncResponseTransformer<T, T> createTransformer() {
         return new IndividualFileTransformer();
     }
 
+    private void onCancel() {
+        subscriber = null;
+    }
+
     /**
      * This is the AsyncResponseTransformer that will be used for each individual requests.
      * <p>
@@ -106,7 +110,9 @@ public void onResponse(T response) {
             List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
             if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
                 // Bad state! This is intended to cancel everything
-                subscriber.onError(new IllegalStateException("Content range header is missing"));
+                if (subscriber != null) {
+                    subscriber.onError(new IllegalStateException("Content range header is missing"));
+                }
                 return;
             }
 
@@ -114,7 +120,9 @@ public void onResponse(T response) {
             Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
             if (!contentRangePair.isPresent()) {
                 // Bad state! This is intended to cancel everything
-                subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
+                if (subscriber != null) {
+                    subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
+                }
                 return;
             }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
index cffa2ec62a7a..6cff201e7a8a 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
@@ -27,13 +27,14 @@
 public class ThreadSafeEmittingSubscription<T> implements Subscription {
 
     private final AtomicBoolean emitting = new AtomicBoolean(false);
-    private final Subscriber<T> downstreamSubscriber;
     private final AtomicLong outstandingDemand;
     private final Runnable onCancel;
     private final AtomicBoolean isCancelled;
     private final Supplier<T> supplier;
     private final Logger log;
 
+    private Subscriber<T> downstreamSubscriber;
+
     public ThreadSafeEmittingSubscription(Subscriber<T> downstreamSubscriber, AtomicLong outstandingDemand,
                                           Runnable onCancel, AtomicBoolean isCancelled, Logger log, Supplier<T> supplier) {
         this.downstreamSubscriber = downstreamSubscriber;
@@ -62,6 +63,8 @@ public void request(long n) {
 
     @Override
     public void cancel() {
+        isCancelled.set(true);
+        downstreamSubscriber = null;
         onCancel.run();
     }
 
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java
new file mode 100644
index 000000000000..6f8c1616dda5
--- /dev/null
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.core.internal.async;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import java.nio.file.FileSystem;
+import java.nio.file.Path;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.tck.PublisherVerification;
+import org.reactivestreams.tck.TestEnvironment;
+import software.amazon.awssdk.core.SdkResponse;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
+
+public class FileAsyncResponseTransformerPublisherTckTest extends PublisherVerification<AsyncResponseTransformer<SdkResponse,
+    SdkResponse>> {
+
+    private final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.unix());
+    private final Path testFile = fileSystem.getPath("/test-file.txt");
+
+
+    public FileAsyncResponseTransformerPublisherTckTest() {
+        super(new TestEnvironment());
+    }
+
+    @Override
+    public Publisher<AsyncResponseTransformer<SdkResponse, SdkResponse>> createPublisher(long elements) {
+        FileAsyncResponseTransformer<?> art =
+            (FileAsyncResponseTransformer<?>) AsyncResponseTransformer.toFile(testFile);
+        FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
+            new FileAsyncResponseTransformerPublisher<>(art);
+
+        return SdkPublisher.adapt(publisher).limit((int) elements);
+    }
+
+    @Override
+    public Publisher<AsyncResponseTransformer<SdkResponse, SdkResponse>> createFailedPublisher() {
+        return null;
+    }
+
+    @Override
+    public long maxElementsFromPublisher() {
+        return Long.MAX_VALUE;
+    }
+
+}
\ No newline at end of file
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 1a9ec9a395fd..9c71388d5af0 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -182,7 +182,6 @@ private void executeRequestOrAddToPending(AsyncResponseTransformer<GetObjectResp
 
         sendNextRequest(asyncResponseTransformer);
         requestMoreIfNeeded();
-
     }
 
     // Handle first request.
@@ -225,6 +224,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
 
         inFlightRequests.put(partToGet, response);
+        CompletableFutureUtils.forwardExceptionTo(resultFuture, response);
 
         response.whenComplete((res, e) -> {
             log.info(() -> "Completed part: " + partToGet);
@@ -311,10 +311,12 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
 
     private void processPendingTransformers() {
         synchronized (pendingTransformers) {
-            AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = pendingTransformers.poll();
-            while (transformer != null) {
-                executeRequestOrAddToPending(transformer);
-                transformer = pendingTransformers.poll();
+            int initialSize = pendingTransformers.size();
+            for (int i = 0; i < initialSize; i++) {
+                AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = pendingTransformers.poll();
+                if (transformer != null) {
+                    executeRequestOrAddToPending(transformer);
+                }
             }
         }
     }

From 29f899d3a07b886d9310e31eb97136ba28753da8 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 11 Sep 2025 16:36:20 -0400
Subject: [PATCH 18/41] Make download method of TM work properly with
 progressUpdater

---
 .../AsyncResponseTransformerListener.java        |  6 ++++++
 .../async/FileAsyncResponseTransformer.java      |  4 +++-
 .../s3/internal/GenericS3TransferManager.java    | 16 ++++++++++++----
 3 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/listener/AsyncResponseTransformerListener.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/listener/AsyncResponseTransformerListener.java
index c7ee37690ca0..f1612e1b1f3e 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/listener/AsyncResponseTransformerListener.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/listener/AsyncResponseTransformerListener.java
@@ -20,6 +20,7 @@
 import org.reactivestreams.Subscriber;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
+import software.amazon.awssdk.core.SplittingTransformerConfiguration;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
 import software.amazon.awssdk.utils.Logger;
@@ -108,6 +109,11 @@ public String name() {
             return delegate.name();
         }
 
+        @Override
+        public SplitResult<ResponseT, ResultT> split(SplittingTransformerConfiguration splitConfig) {
+            return delegate.split(splitConfig);
+        }
+
         static void invoke(Runnable runnable, String callbackName) {
             try {
                 runnable.run();
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 07d631030a4f..fc6dd4ad5831 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -305,7 +305,9 @@ public String toString() {
     @Override
     public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
         if (configuration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
-            return AsyncResponseTransformer.super.split(splitConfig);
+            return AsyncResponseTransformer.super.
+                split(splitConfig)
+                .copy(res -> res.supportsNonSerial(false));
         }
         return AsyncResponseTransformer.super
             .split(splitConfig)
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
index afe397e269e8..a2ffd5d03846 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
@@ -341,10 +341,18 @@ public final <ResultT> Download<ResultT> download(DownloadRequest<ResultT> downl
 
         TransferProgressUpdater progressUpdater = new TransferProgressUpdater(downloadRequest, null);
         progressUpdater.transferInitiated();
-        responseTransformer = isS3ClientMultipartEnabled()
-                              ? progressUpdater.wrapResponseTransformerForMultipartDownload(
-            responseTransformer, downloadRequest.getObjectRequest())
-                              : progressUpdater.wrapResponseTransformer(responseTransformer);
+        if (isS3ClientMultipartEnabled()) {
+            // TODO find a better way to do that
+            if (responseTransformer.split(b -> b.bufferSizeInBytes(1L)).supportsNonSerial()) {
+                responseTransformer =
+                    progressUpdater.wrapForNonSerialFileDownload(responseTransformer, downloadRequest.getObjectRequest());
+            } else {
+                responseTransformer =
+                    progressUpdater.wrapResponseTransformerForMultipartDownload(responseTransformer, downloadRequest.getObjectRequest());
+            }
+        } else {
+            responseTransformer = progressUpdater.wrapResponseTransformer(responseTransformer);
+        }
         progressUpdater.registerCompletion(returnFuture);
 
         try {

From 0aa15298f490ab11ecac60c5cf995366ec5de90c Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 12 Sep 2025 15:17:43 -0400
Subject: [PATCH 19/41] remove logs

---
 .../NonLinearMultipartDownloaderSubscriber.java    | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 9c71388d5af0..abba651db140 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -242,12 +242,8 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             if (completedParts.get() >= totalParts) {
                 // todo remove log
                 log.info(() -> "================= ALL PARTS COMPLETED ==================");
-                log.info(() -> "remaining in flight (should be empty): " + inFlightRequests.keySet().toString());
-                log.info(() -> "calling cancel");
                 subscription.cancel();
-                log.info(() -> "completing future");
                 resultFuture.complete(getObjectResponse);
-                log.info(() -> "all done in NonLinearMultipartDownloaderSubscriber");
             } else {
                 processPendingTransformers();
                 requestMoreIfNeeded();
@@ -335,8 +331,8 @@ private void requestMoreIfNeeded() {
         int totalWorkInProgress = inFlightRequests.size() + completedParts.get();
         if (totalWorkInProgress >= totalParts) {
             // todo change trace log
-            log.info(() -> "Not requesting more. Total work in progress (" + totalWorkInProgress
-                           + ") >= totalParts (" + totalParts + ")");
+            // log.info(() -> "Not requesting more. Total work in progress (" + totalWorkInProgress
+            //                + ") >= totalParts (" + totalParts + ")");
             return;
         }
 
@@ -360,9 +356,9 @@ private void requestMoreIfNeeded() {
                                    maxInFlight - inFlightRequests.size());
         if (partsNeeded > 0) {
             // todo change trace log
-            log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
-                           + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
-                           + ". InFlight: " + inFlightRequests.size());
+            // log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
+            //                + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
+            //                + ". InFlight: " + inFlightRequests.size());
             request(partsNeeded);
         }
 

From 426d82d2bdb60e9faa1b150e8298f87f57364e92 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 11:11:30 -0400
Subject: [PATCH 20/41] add ParallelConfiguration for maxInFlightParts

---
 ...partClientFileDownloadIntegrationTest.java |  1 -
 .../MultipartConfigurationResolver.java       | 18 ++++--
 .../multipart/MultipartS3AsyncClient.java     |  2 +-
 .../s3/multipart/MultipartConfiguration.java  | 42 +++++++++----
 .../s3/multipart/ParallelConfiguration.java   | 61 +++++++++++++++++++
 .../MultipartConfigurationResolverTest.java   | 28 +++++++--
 6 files changed, 128 insertions(+), 24 deletions(-)
 create mode 100644 services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java

diff --git a/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
index a9fced5873f2..10823cb5937a 100644
--- a/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
+++ b/services/s3/src/it/java/software/amazon/awssdk/services/s3/multipart/S3MultipartClientFileDownloadIntegrationTest.java
@@ -87,7 +87,6 @@ public void init() {
         this.interceptor = new TestInterceptor();
         this.s3Client = S3AsyncClient.builder()
                                      .multipartEnabled(true)
-                                     .multipartConfiguration(c -> c.maxInflightDownloads(50))
                                      .overrideConfiguration(o -> o.addExecutionInterceptor(this.interceptor))
                                      .credentialsProvider(CREDENTIALS_PROVIDER_CHAIN)
                                      .build();
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
index c63a66bb672e..6d8358e72efa 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
@@ -17,6 +17,7 @@
 
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.services.s3.multipart.MultipartConfiguration;
+import software.amazon.awssdk.services.s3.multipart.ParallelConfiguration;
 import software.amazon.awssdk.utils.Validate;
 
 /**
@@ -26,11 +27,12 @@
 public final class MultipartConfigurationResolver {
 
     private static final long DEFAULT_MIN_PART_SIZE = 8L * 1024 * 1024;
-    private static final int DEFAULT_MAX_IN_FLIGHT = 50;
+    private static final int DEFAULT_MAX_IN_FLIGHT_PARTS = 50;
+
     private final long minimalPartSizeInBytes;
     private final long apiCallBufferSize;
     private final long thresholdInBytes;
-    private final int maxInFlight;
+    private final int maxInFlightParts;
 
     public MultipartConfigurationResolver(MultipartConfiguration multipartConfiguration) {
         Validate.notNull(multipartConfiguration, "multipartConfiguration");
@@ -39,7 +41,13 @@ public MultipartConfigurationResolver(MultipartConfiguration multipartConfigurat
         this.apiCallBufferSize = Validate.getOrDefault(multipartConfiguration.apiCallBufferSizeInBytes(),
                                                        () -> minimalPartSizeInBytes * 4);
         this.thresholdInBytes = Validate.getOrDefault(multipartConfiguration.thresholdInBytes(), () -> minimalPartSizeInBytes);
-        this.maxInFlight = Validate.getOrDefault(multipartConfiguration.maxInflightDownloads(), () -> DEFAULT_MAX_IN_FLIGHT);
+        ParallelConfiguration parallelConfiguration = multipartConfiguration.parallelConfiguration();
+        if (parallelConfiguration == null) {
+            this.maxInFlightParts = DEFAULT_MAX_IN_FLIGHT_PARTS;
+        } else {
+            this.maxInFlightParts = Validate.getOrDefault(multipartConfiguration.parallelConfiguration().maxInFlightParts(),
+                                                          () -> DEFAULT_MAX_IN_FLIGHT_PARTS);
+        }
     }
 
     public long minimalPartSizeInBytes() {
@@ -54,7 +62,7 @@ public long apiCallBufferSize() {
         return apiCallBufferSize;
     }
 
-    public int maxInFlight() {
-        return maxInFlight;
+    public int maxInFlightParts() {
+        return maxInFlightParts;
     }
 }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
index 3ba362ccae55..7cd4a43c73d5 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
@@ -63,7 +63,7 @@ private MultipartS3AsyncClient(S3AsyncClient delegate, MultipartConfiguration mu
         long minPartSizeInBytes = resolver.minimalPartSizeInBytes();
         long threshold = resolver.thresholdInBytes();
         long apiCallBufferSize = resolver.apiCallBufferSize();
-        int maxInFLight = resolver.maxInFlight();
+        int maxInFLight = resolver.maxInFlightParts();
         mpuHelper = new UploadObjectHelper(delegate, resolver);
         copyObjectHelper = new CopyObjectHelper(delegate, minPartSizeInBytes, threshold);
         downloadObjectHelper = new DownloadObjectHelper(delegate, apiCallBufferSize, maxInFLight);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
index d586afdaa8a2..2e1cba362ff4 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
@@ -15,6 +15,7 @@
 
 package software.amazon.awssdk.services.s3.multipart;
 
+import java.util.function.Consumer;
 import software.amazon.awssdk.annotations.SdkPublicApi;
 import software.amazon.awssdk.core.async.AsyncRequestBody;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
@@ -44,13 +45,13 @@ public final class MultipartConfiguration implements ToCopyableBuilder<Multipart
     private final Long thresholdInBytes;
     private final Long minimumPartSizeInBytes;
     private final Long apiCallBufferSizeInBytes;
-    private final Integer maxInflightDownloads;
+    private final ParallelConfiguration parallelConfiguration;;
 
     private MultipartConfiguration(DefaultMultipartConfigBuilder builder) {
         this.thresholdInBytes = builder.thresholdInBytes;
         this.minimumPartSizeInBytes = builder.minimumPartSizeInBytes;
         this.apiCallBufferSizeInBytes = builder.apiCallBufferSizeInBytes;
-        this.maxInflightDownloads = builder.maxInflightDownloads;
+        this.parallelConfiguration = builder.parallelConfiguration;
     }
 
     public static Builder builder() {
@@ -91,8 +92,12 @@ public Long apiCallBufferSizeInBytes() {
         return this.apiCallBufferSizeInBytes;
     }
 
-    public Integer maxInflightDownloads() {
-        return this.maxInflightDownloads;
+    /**
+     *
+     * @return
+     */
+    public ParallelConfiguration parallelConfiguration() {
+        return this.parallelConfiguration;
     }
 
     /**
@@ -172,16 +177,18 @@ public interface Builder extends CopyableBuilder<Builder, MultipartConfiguration
 
         /**
          * todo
-         * @param maxInflightDownloads
+         * @param
          * @return
          */
-        Builder maxInflightDownloads(Integer maxInflightDownloads);
+        Builder parallelConfiguration(ParallelConfiguration parallelConfiguration);
+
+        Builder parallelConfiguration(Consumer<ParallelConfiguration.Builder> consumer);
 
         /**
          * todo
          * @return
          */
-        Integer maxInflightDownloads();
+        ParallelConfiguration parallelConfiguration();
 
     }
 
@@ -189,35 +196,46 @@ private static class DefaultMultipartConfigBuilder implements Builder {
         private Long thresholdInBytes;
         private Long minimumPartSizeInBytes;
         private Long apiCallBufferSizeInBytes;
-        private Integer maxInflightDownloads;
+        private ParallelConfiguration parallelConfiguration;
 
+        @Override
         public Builder thresholdInBytes(Long thresholdInBytes) {
             this.thresholdInBytes = thresholdInBytes;
             return this;
         }
 
+        @Override
         public Long thresholdInBytes() {
             return this.thresholdInBytes;
         }
 
+        @Override
         public Builder minimumPartSizeInBytes(Long minimumPartSizeInBytes) {
             this.minimumPartSizeInBytes = minimumPartSizeInBytes;
             return this;
         }
 
+        @Override
         public Long minimumPartSizeInBytes() {
             return this.minimumPartSizeInBytes;
         }
 
         @Override
-        public Builder maxInflightDownloads(Integer maxInflightDownloads) {
-            this.maxInflightDownloads = maxInflightDownloads;
+        public Builder parallelConfiguration(ParallelConfiguration parallelConfiguration) {
+            this.parallelConfiguration = parallelConfiguration;
             return this;
         }
 
         @Override
-        public Integer maxInflightDownloads() {
-            return this.maxInflightDownloads;
+        public Builder parallelConfiguration(Consumer<ParallelConfiguration.Builder> configuration) {
+            ParallelConfiguration.Builder builder = ParallelConfiguration.builder();
+            configuration.accept(builder);
+            return parallelConfiguration(builder.build());
+        }
+
+        @Override
+        public ParallelConfiguration parallelConfiguration() {
+            return this.parallelConfiguration;
         }
 
         @Override
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java
new file mode 100644
index 000000000000..05bfacf0354a
--- /dev/null
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.multipart;
+
+import software.amazon.awssdk.annotations.SdkPublicApi;
+import software.amazon.awssdk.utils.builder.CopyableBuilder;
+import software.amazon.awssdk.utils.builder.ToCopyableBuilder;
+
+@SdkPublicApi
+public class ParallelConfiguration implements ToCopyableBuilder<ParallelConfiguration.Builder, ParallelConfiguration> {
+
+    private final Integer maxInFlightParts;
+
+    public ParallelConfiguration(Builder builder) {
+        this.maxInFlightParts = builder.maxInFlightParts;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public Integer maxInFlightParts() {
+        return maxInFlightParts;
+    }
+
+    @Override
+    public Builder toBuilder() {
+        return builder().maxInFlightParts(maxInFlightParts);
+    }
+
+    public static class Builder implements CopyableBuilder<Builder, ParallelConfiguration> {
+        private int maxInFlightParts;
+
+        public Builder maxInFlightParts(int maxInFlightParts) {
+            this.maxInFlightParts = maxInFlightParts;
+            return this;
+        }
+
+        public int maxInFlightParts() {
+            return maxInFlightParts;
+        }
+
+        @Override
+        public ParallelConfiguration build() {
+            return new ParallelConfiguration(this);
+        }
+    }
+}
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolverTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolverTest.java
index 99e929c09f4e..18e4348a247a 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolverTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolverTest.java
@@ -19,6 +19,7 @@
 
 import org.junit.jupiter.api.Test;
 import software.amazon.awssdk.services.s3.multipart.MultipartConfiguration;
+import software.amazon.awssdk.services.s3.multipart.ParallelConfiguration;
 
 public class MultipartConfigurationResolverTest {
 
@@ -59,17 +60,32 @@ void resolveApiCallBufferSize_valueNotProvided_shouldComputeBasedOnPartSize() {
         assertThat(resolver.apiCallBufferSize()).isEqualTo(40L);
     }
 
+    @Test
+    void resolveMaxInFlightParts_valueProvidedWithBuilder_shouldHonor() {
+        MultipartConfiguration configuration =
+            MultipartConfiguration.builder()
+                                  .parallelConfiguration(p -> p.maxInFlightParts(1))
+                                  .build();
+        MultipartConfigurationResolver resolver = new MultipartConfigurationResolver(configuration);
+        assertThat(resolver.maxInFlightParts()).isEqualTo(1);
+    }
+
     @Test
     void valueProvidedForAllFields_shouldHonor() {
-        MultipartConfiguration configuration = MultipartConfiguration.builder()
-                                                                     .minimumPartSizeInBytes(10L)
-                                                                     .thresholdInBytes(8L)
-                                                                     .apiCallBufferSizeInBytes(3L)
-                                                                     .build();
+        MultipartConfiguration configuration =
+            MultipartConfiguration.builder()
+                                  .minimumPartSizeInBytes(10L)
+                                  .thresholdInBytes(8L)
+                                  .apiCallBufferSizeInBytes(3L)
+                                  .parallelConfiguration(ParallelConfiguration.builder()
+                                                                              .maxInFlightParts(1)
+                                                                              .build())
+                                  .build();
         MultipartConfigurationResolver resolver = new MultipartConfigurationResolver(configuration);
         assertThat(resolver.minimalPartSizeInBytes()).isEqualTo(10L);
         assertThat(resolver.thresholdInBytes()).isEqualTo(8L);
         assertThat(resolver.apiCallBufferSize()).isEqualTo(3L);
+        assertThat(resolver.maxInFlightParts()).isEqualTo(1);
     }
 
     @Test
@@ -79,5 +95,7 @@ void noValueProvided_shouldUseDefault() {
         assertThat(resolver.minimalPartSizeInBytes()).isEqualTo(8L * 1024 * 1024);
         assertThat(resolver.thresholdInBytes()).isEqualTo(8L * 1024 * 1024);
         assertThat(resolver.apiCallBufferSize()).isEqualTo(8L * 1024 * 1024 * 4);
+        assertThat(resolver.maxInFlightParts()).isEqualTo(50);
     }
+
 }

From 5bdc14255afdd2caf10b7e935caf120285216b3e Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 11:40:25 -0400
Subject: [PATCH 21/41] javadoc and logs

---
 ...FileAsyncResponseTransformerPublisher.java |  3 -
 ...onLinearMultipartDownloaderSubscriber.java | 73 +++++++++----------
 .../s3/multipart/MultipartConfiguration.java  | 20 +++--
 3 files changed, 47 insertions(+), 49 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 752e468d7e59..c25d9f6bae3d 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -109,7 +109,6 @@ public CompletableFuture<T> prepare() {
         public void onResponse(T response) {
             List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
             if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
-                // Bad state! This is intended to cancel everything
                 if (subscriber != null) {
                     subscriber.onError(new IllegalStateException("Content range header is missing"));
                 }
@@ -119,7 +118,6 @@ public void onResponse(T response) {
             String contentRange = contentRangeList.get(0);
             Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
             if (!contentRangePair.isPresent()) {
-                // Bad state! This is intended to cancel everything
                 if (subscriber != null) {
                     subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
                 }
@@ -173,7 +171,6 @@ public void onStream(SdkPublisher<ByteBuffer> publisher) {
 
         @Override
         public void exceptionOccurred(Throwable error) {
-            log.error(() -> "error detected", error);
             if (delegate != null) {
                 // do not call onError, because exceptionOccurred may be called multiple times due to retries, simply forward the
                 // error to the delegate async response transformer which will let the service call pipeline handle the error.
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index abba651db140..474ab59932d7 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -33,6 +33,14 @@
 import software.amazon.awssdk.utils.CompletableFutureUtils;
 import software.amazon.awssdk.utils.Logger;
 
+/**
+ * A subscriber implementation that will download all individual parts for a multipart get-object request in parallel,
+ * concurrently. The amount of concurrent get-object is limited by the {@code maxInFlightParts} configuration. It receives the
+ * individual {@link AsyncResponseTransformer} which will be used to perform the individual part requests. These
+ * AsyncResponseTransformer should be able to handle receiving data in parts potentially out of order, For example, the
+ * AsyncResponseTransformer for part 4 might may have any of its callback called before part 1, 2 or 3 if it finishes before. This
+ * is a 'one-shot' class, it should <em>NOT</em> be reused for more than one multipart download.
+ */
 @SdkInternalApi
 public class NonLinearMultipartDownloaderSubscriber
     implements Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
@@ -41,7 +49,7 @@ public class NonLinearMultipartDownloaderSubscriber
     /**
      * Maximum number of concurrent GetObject requests
      */
-    private final int maxInFlight;
+    private final int maxInFlightParts;
 
     /**
      * The s3 client used to make the individual part requests
@@ -61,7 +69,7 @@ public class NonLinearMultipartDownloaderSubscriber
     private final AtomicInteger completedParts = new AtomicInteger();
 
     /**
-     * Queue of all remaining parts in ascending order. i.e. 4, 5, 6, 8, 11
+     * Queue of all remaining parts in ascending order. i.e. 4, 5, 6, 8, 11, etc
      */
     private final Queue<Integer> allRemainingParts = new ArrayDeque<>();
 
@@ -107,8 +115,7 @@ public class NonLinearMultipartDownloaderSubscriber
     private final ReentrantLock firstPartLock = new ReentrantLock();
 
     /**
-     * Pending transformers waiting for the first request to be executed. We cant execute multiple part get until the first
-     * requests completes, and we know the object in s3 is a multipart object.
+     * Pending transformers received through onNext that are waiting to be executed.
      */
     private final Queue<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> pendingTransformers = new ArrayDeque<>();
 
@@ -134,7 +141,7 @@ public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
         this.s3 = s3;
         this.getObjectRequest = getObjectRequest;
         this.resultFuture = resultFuture;
-        this.maxInFlight = maxInFLight;
+        this.maxInFlightParts = maxInFLight;
     }
 
     @Override
@@ -155,14 +162,13 @@ private void request(int amount) {
 
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        // todo change to trace log
         outstandingDemand.decrementAndGet();
-        log.info(() -> "=== On Next ===\nTotal in flight parts: " + inFlightRequests.size()
-                       + "\nOutstanding Demand : " + outstandingDemand.get()
-                       + "\nTotal completed parts: " + completedParts
-                       + "\nTotal transformers requested: " + transformersRequested.get()
-                       + "\nTotal pending transformers: " + pendingTransformers.size()
-                       + "\nCurrent in flight requests: " + inFlightRequests.keySet());
+        log.trace(() -> "=== On Next ===\nTotal in flight parts: " + inFlightRequests.size()
+                        + "\nOutstanding Demand : " + outstandingDemand.get()
+                        + "\nTotal completed parts: " + completedParts
+                        + "\nTotal transformers requested: " + transformersRequested.get()
+                        + "\nTotal pending transformers: " + pendingTransformers.size()
+                        + "\nCurrent in flight requests: " + inFlightRequests.keySet());
         if (asyncResponseTransformer == null) {
             subscription.cancel();
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
@@ -175,7 +181,7 @@ private void executeRequestOrAddToPending(AsyncResponseTransformer<GetObjectResp
             return;
         }
 
-        if (inFlightRequests.size() >= maxInFlight) {
+        if (inFlightRequests.size() >= maxInFlightParts) {
             pendingTransformers.offer(asyncResponseTransformer);
             return;
         }
@@ -218,8 +224,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         Integer partToGet = nextPart();
 
         GetObjectRequest request = nextRequest(partToGet);
-        // todo change to trace log
-        log.info(() -> "Sending next request for part: " + partToGet);
+        log.debug(() -> "Sending next request for part: " + partToGet);
 
         CompletableFuture<GetObjectResponse> response = s3.getObject(request, asyncResponseTransformer);
 
@@ -227,7 +232,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         CompletableFutureUtils.forwardExceptionTo(resultFuture, response);
 
         response.whenComplete((res, e) -> {
-            log.info(() -> "Completed part: " + partToGet);
+            log.debug(() -> "Completed part: " + partToGet);
             inFlightRequests.remove(partToGet);
 
             completedParts.incrementAndGet();
@@ -240,8 +245,6 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
                 return;
             }
             if (completedParts.get() >= totalParts) {
-                // todo remove log
-                log.info(() -> "================= ALL PARTS COMPLETED ==================");
                 subscription.cancel();
                 resultFuture.complete(getObjectResponse);
             } else {
@@ -253,7 +256,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
 
     // returns true if the first request was sent and is still in flight
     private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        log.info(() -> "Sending first request");
+        log.debug(() -> "Sending first request");
         GetObjectRequest request = nextRequest(1);
         CompletableFuture<GetObjectResponse> responseFuture = s3.getObject(request, asyncResponseTransformer);
         inFlightRequests.put(1, responseFuture);
@@ -262,7 +265,8 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         CompletableFutureUtils.forwardExceptionTo(resultFuture, responseFuture);
 
         responseFuture.whenComplete((res, e) -> {
-           inFlightRequests.remove(1);
+            log.debug(() -> "Completed part: 1");
+            inFlightRequests.remove(1);
 
             completedParts.incrementAndGet();
             if (e != null) {
@@ -275,8 +279,7 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             Integer partCount = res.partsCount();
             eTag = res.eTag();
             if (partCount != null && totalParts == null) {
-                // todo change debug log
-                log.info(() -> String.format("Total amount of parts of the object to download: %d", partCount));
+                log.debug(() -> String.format("Total amount of parts of the object to download: %d", partCount));
                 // MultipartDownloadUtils.multipartDownloadResumeContext(getObjectRequest)
                 //                       .ifPresent(ctx -> ctx.totalParts(partCount));
                 totalParts = partCount;
@@ -286,14 +289,13 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             if (totalParts == null || totalParts == 1) {
                 // Single part object detected, skip multipart and complete everything now
                 // todo change debug log
-                log.info(() -> "Single Part object detected, skipping multipart download");
+                log.debug(() -> "Single Part object detected, skipping multipart download");
                 subscription.cancel();
                 resultFuture.complete(res);
                 return;
             }
 
-            // todo change debug log
-            log.info(() -> "Multipart object detected, performing multipart download");
+            log.debug(() -> "Multipart object detected, performing multipart download");
             // part 1 already completed, so skip it
             for (int i = 2; i <= totalParts; i++) {
                 allRemainingParts.add(i);
@@ -330,9 +332,6 @@ private void requestMoreIfNeeded() {
         // Don't request more if we already have enough work in progress
         int totalWorkInProgress = inFlightRequests.size() + completedParts.get();
         if (totalWorkInProgress >= totalParts) {
-            // todo change trace log
-            // log.info(() -> "Not requesting more. Total work in progress (" + totalWorkInProgress
-            //                + ") >= totalParts (" + totalParts + ")");
             return;
         }
 
@@ -343,22 +342,20 @@ private void requestMoreIfNeeded() {
         }
 
         // don't request if we already have enough work in progress
-        if (inFlightRequests.size() >= maxInFlight) {
+        if (inFlightRequests.size() >= maxInFlightParts) {
             return;
         }
 
         // don't request if we have already requested more work than we can handle
-        if (outstandingDemand.get() >= maxInFlight) {
+        if (outstandingDemand.get() >= maxInFlightParts) {
             return;
         }
 
         int partsNeeded = Math.min(Math.min(totalParts - currentRequested, remainingParts),
-                                   maxInFlight - inFlightRequests.size());
+                                   maxInFlightParts - inFlightRequests.size());
         if (partsNeeded > 0) {
-            // todo change trace log
-            // log.info(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
-            //                + (currentRequested + partsNeeded) + ". Remaining parts: " + remainingParts
-            //                + ". InFlight: " + inFlightRequests.size());
+            log.trace(() -> "Requesting " + partsNeeded + " more transformers. Total requested will be: "
+                            + (currentRequested + partsNeeded));
             request(partsNeeded);
         }
 
@@ -372,9 +369,9 @@ private Integer nextPart() {
 
     @Override
     public void onError(Throwable t) {
-        // Signal received from the publisher this is subscribed to, in the case of file download, that's
-        // FileAsyncResponseTransformerPublisher.
-        // failed state, something really wrong has happened, cancel everything
+        // Signal received from the publisher this is subscribed to
+        // (in the case of file download, that's FileAsyncResponseTransformerPublisher)
+        // Failed state, something really wrong has happened, cancel everything
         inFlightRequests.values().forEach(future -> future.cancel(true));
         inFlightRequests.clear();
         resultFuture.completeExceptionally(t);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
index 2e1cba362ff4..feeaecace500 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
@@ -93,8 +93,8 @@ public Long apiCallBufferSizeInBytes() {
     }
 
     /**
-     *
-     * @return
+     * Configuration specifically related to parallel multipart operations.
+     * @return the configuration class
      */
     public ParallelConfiguration parallelConfiguration() {
         return this.parallelConfiguration;
@@ -176,20 +176,24 @@ public interface Builder extends CopyableBuilder<Builder, MultipartConfiguration
         Long apiCallBufferSizeInBytes();
 
         /**
-         * todo
-         * @param
-         * @return
+         * Configuration specifically related to parallel multipart operations.
+         * @param parallelConfiguration the configuration class
+         * @return an instance of this builder.
          */
         Builder parallelConfiguration(ParallelConfiguration parallelConfiguration);
 
+        /**
+         * Configuration specifically related to parallel multipart operations.
+         * @param consumer consumer class for fluent builder
+         * @return an instance of this builder.
+         */
         Builder parallelConfiguration(Consumer<ParallelConfiguration.Builder> consumer);
 
         /**
-         * todo
-         * @return
+         * Configuration specifically related to parallel multipart operations.
+         * @return the configuration class
          */
         ParallelConfiguration parallelConfiguration();
-
     }
 
     private static class DefaultMultipartConfigBuilder implements Builder {

From 474111b545ce514f3d07a9b8dc6552e4028649f9 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 12:21:37 -0400
Subject: [PATCH 22/41] cleanup and changelog

---
 .changes/next-release/feature-S3-12a0b55.json |  6 ++++++
 .idea/codeStyles/Project.xml                  |  1 -
 .../async/FileAsyncResponseTransformer.java   |  6 ++++--
 .../async/FileSplittingTransformer.java       | 19 -------------------
 ...ncResponseTransformerPublisherTckTest.java |  2 +-
 .../internal/async/FileSubscriberTckTest.java |  6 ++++--
 .../multipart/DownloadObjectHelper.java       |  1 -
 .../multipart/MultipartS3AsyncClient.java     |  4 ++--
 ...onLinearMultipartDownloaderSubscriber.java | 12 ++++++------
 .../s3/multipart/ParallelConfiguration.java   | 10 ++++++++++
 .../amazon/awssdk/utils/ToString.java         |  1 -
 11 files changed, 33 insertions(+), 35 deletions(-)
 create mode 100644 .changes/next-release/feature-S3-12a0b55.json
 delete mode 100644 core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java

diff --git a/.changes/next-release/feature-S3-12a0b55.json b/.changes/next-release/feature-S3-12a0b55.json
new file mode 100644
index 000000000000..0be1c7b5691e
--- /dev/null
+++ b/.changes/next-release/feature-S3-12a0b55.json
@@ -0,0 +1,6 @@
+{
+    "type": "feature",
+    "category": "S3",
+    "contributor": "",
+    "description": "Add support for parallel download for individual part-get for multipart GetObject in s3 async client and Transfer Manager"
+}
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 31e3dd29a01f..82511b2671f7 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -10,7 +10,6 @@
       </option>
       <option name="IMPORT_LAYOUT_TABLE">
         <value>
-          <package name="" withSubpackages="true" static="false" module="true" />
           <package name="" withSubpackages="true" static="true" />
           <emptyLine />
           <package name="" withSubpackages="true" static="false" />
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index fc6dd4ad5831..af3efa79a457 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -179,7 +179,6 @@ public void exceptionOccurred(Throwable throwable) {
             }
         }
         if (cf != null) {
-            log.info(() -> "completing file future exceptionally");
             cf.completeExceptionally(throwable);
         } else {
             log.warn(() -> "An exception occurred before the call to prepare() was able to instantiate the CompletableFuture."
@@ -192,6 +191,9 @@ public String name() {
         return TransformerType.FILE.getName();
     }
 
+    /**
+     * {@link Subscriber} implementation that writes chunks to a file.
+     */
     static class FileSubscriber implements Subscriber<ByteBuffer> {
         private final AtomicLong position;
         private final AsynchronousFileChannel fileChannel;
@@ -205,7 +207,7 @@ static class FileSubscriber implements Subscriber<ByteBuffer> {
         private Subscription subscription;
 
         FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
-                              Consumer<Throwable> onErrorMethod, long startingPosition) {
+                       Consumer<Throwable> onErrorMethod, long startingPosition) {
             this.fileChannel = fileChannel;
             this.path = path;
             this.future = future;
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java
deleted file mode 100644
index eb4a5b21b193..000000000000
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileSplittingTransformer.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License").
- * You may not use this file except in compliance with the License.
- * A copy of the License is located at
- *
- *  http://aws.amazon.com/apache2.0
- *
- * or in the "license" file accompanying this file. This file is distributed
- * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package software.amazon.awssdk.core.internal.async;
-
-public class FileSplittingTransformer {
-}
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java
index 6f8c1616dda5..fbc0ae4662f5 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTckTest.java
@@ -57,4 +57,4 @@ public long maxElementsFromPublisher() {
         return Long.MAX_VALUE;
     }
 
-}
\ No newline at end of file
+}
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
index 1937de5220e1..a22634c12986 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
@@ -31,9 +31,11 @@
 import org.reactivestreams.Subscription;
 import org.reactivestreams.tck.SubscriberWhiteboxVerification;
 import org.reactivestreams.tck.TestEnvironment;
+import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer.FileSubscriber;
+
 
 /**
- * TCK verification test for {@link FileAsyncResponseTransformer.FileSubscriber}.
+ * TCK verification test for {@link FileSubscriber}.
  */
 public class FileSubscriberTckTest extends SubscriberWhiteboxVerification<ByteBuffer> {
     private static final byte[] CONTENT = new byte[16];
@@ -46,7 +48,7 @@ public FileSubscriberTckTest() {
     @Override
     public Subscriber<ByteBuffer> createSubscriber(WhiteboxSubscriberProbe<ByteBuffer> whiteboxSubscriberProbe) {
         Path tempFile = getNewTempFile();
-        return new FileAsyncResponseTransformer.FileSubscriber(openChannel(tempFile), tempFile, new CompletableFuture<>(), (t) -> {}, 0) {
+        return new FileSubscriber(openChannel(tempFile), tempFile, new CompletableFuture<>(), (t) -> {}, 0) {
             @Override
             public void onSubscribe(Subscription s) {
                 super.onSubscribe(s);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 0a1c030f3bfb..1802d301d310 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -62,7 +62,6 @@ private <T> CompletableFuture<T> downloadPartsNonSerially(
         GetObjectRequest getObjectRequest,
         AsyncResponseTransformer.SplitResult<GetObjectResponse, T> split,
         int maxInFlight) {
-        // TODO pause & resume
         NonLinearMultipartDownloaderSubscriber subscriber = new NonLinearMultipartDownloaderSubscriber(
             s3AsyncClient, getObjectRequest, (CompletableFuture<GetObjectResponse>) split.resultFuture(), maxInFlight);
         split.publisher().subscribe(subscriber);
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
index 619041f7d2e5..499f36a6dd1b 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartS3AsyncClient.java
@@ -62,10 +62,10 @@ private MultipartS3AsyncClient(S3AsyncClient delegate, MultipartConfiguration mu
         long minPartSizeInBytes = resolver.minimalPartSizeInBytes();
         long threshold = resolver.thresholdInBytes();
         long apiCallBufferSize = resolver.apiCallBufferSize();
-        int maxInFLight = resolver.maxInFlightParts();
+        int maxInFlightParts = resolver.maxInFlightParts();
         mpuHelper = new UploadObjectHelper(delegate, resolver);
         copyObjectHelper = new CopyObjectHelper(delegate, minPartSizeInBytes, threshold);
-        downloadObjectHelper = new DownloadObjectHelper(delegate, apiCallBufferSize, maxInFLight);
+        downloadObjectHelper = new DownloadObjectHelper(delegate, apiCallBufferSize, maxInFlightParts);
         this.checksumEnabled = checksumEnabled;
     }
 
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 474ab59932d7..41815401f184 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -163,12 +163,12 @@ private void request(int amount) {
     @Override
     public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         outstandingDemand.decrementAndGet();
-        log.trace(() -> "=== On Next ===\nTotal in flight parts: " + inFlightRequests.size()
-                        + "\nOutstanding Demand : " + outstandingDemand.get()
-                        + "\nTotal completed parts: " + completedParts
-                        + "\nTotal transformers requested: " + transformersRequested.get()
-                        + "\nTotal pending transformers: " + pendingTransformers.size()
-                        + "\nCurrent in flight requests: " + inFlightRequests.keySet());
+        log.trace(() -> "On Next - Total in flight parts: " + inFlightRequests.size()
+                        + " - Demand : " + outstandingDemand.get()
+                        + " - Total completed parts: " + completedParts
+                        + " - Total transformers requested: " + transformersRequested.get()
+                        + " - Total pending transformers: " + pendingTransformers.size()
+                        + " - Current in flight requests: " + inFlightRequests.keySet());
         if (asyncResponseTransformer == null) {
             subscription.cancel();
             throw new NullPointerException("onNext must not be called with null asyncResponseTransformer");
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java
index 05bfacf0354a..a3816cd97fa2 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/ParallelConfiguration.java
@@ -16,9 +16,15 @@
 package software.amazon.awssdk.services.s3.multipart;
 
 import software.amazon.awssdk.annotations.SdkPublicApi;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.utils.builder.CopyableBuilder;
 import software.amazon.awssdk.utils.builder.ToCopyableBuilder;
 
+/**
+ * Class that holds configuration properties related to multipart operations for a {@link S3AsyncClient}, related specifically
+ * to non-linear, parallel operations, that is, when the {@link AsyncResponseTransformer} supports non-serial split.
+ */
 @SdkPublicApi
 public class ParallelConfiguration implements ToCopyableBuilder<ParallelConfiguration.Builder, ParallelConfiguration> {
 
@@ -32,6 +38,10 @@ public static Builder builder() {
         return new Builder();
     }
 
+    /**
+     * The maximum number of concurrent GetObject the that are allowed for multipart download.
+     * @return The value for the maximum number of concurrent GetObject the that are allowed for multipart download.
+     */
     public Integer maxInFlightParts() {
         return maxInFlightParts;
     }
diff --git a/utils/src/main/java/software/amazon/awssdk/utils/ToString.java b/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
index a066ae68e6e6..6b6fbbbe7a55 100644
--- a/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
+++ b/utils/src/main/java/software/amazon/awssdk/utils/ToString.java
@@ -16,7 +16,6 @@
 package software.amazon.awssdk.utils;
 
 import java.util.Arrays;
-import java.util.concurrent.locks.ReentrantLock;
 import software.amazon.awssdk.annotations.NotThreadSafe;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
 

From 9ad9c5663ea5e1f5e9fb8f031ece0e7d8bab45d9 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 12:25:09 -0400
Subject: [PATCH 23/41] cleanup

---
 .../core/internal/async/FileAsyncResponseTransformer.java | 2 +-
 .../awssdk/core/internal/async/FileSubscriberTckTest.java | 1 -
 .../s3/internal/progress/ContentRangeParserTest.java      | 2 +-
 .../s3/internal/multipart/DownloadObjectHelper.java       | 8 ++++----
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index af3efa79a457..4eba7a721136 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -317,4 +317,4 @@ public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration
                 res -> res.supportsNonSerial(true)
                           .publisher(new FileAsyncResponseTransformerPublisher(this)));
     }
-}
\ No newline at end of file
+}
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
index a22634c12986..8810c3459f25 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileSubscriberTckTest.java
@@ -33,7 +33,6 @@
 import org.reactivestreams.tck.TestEnvironment;
 import software.amazon.awssdk.core.internal.async.FileAsyncResponseTransformer.FileSubscriber;
 
-
 /**
  * TCK verification test for {@link FileSubscriber}.
  */
diff --git a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
index b432d93996a7..b89b7ab3ce7f 100644
--- a/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
+++ b/services-custom/s3-transfer-manager/src/test/java/software/amazon/awssdk/transfer/s3/internal/progress/ContentRangeParserTest.java
@@ -67,4 +67,4 @@ static Stream<Arguments> testRange() {
         );
     }
 
-}
\ No newline at end of file
+}
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 1802d301d310..9b56801fa930 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -32,12 +32,12 @@ public class DownloadObjectHelper {
 
     private final S3AsyncClient s3AsyncClient;
     private final long bufferSizeInBytes;
-    private final int maxInFlight;
+    private final int maxInFlightParts;
 
-    public DownloadObjectHelper(S3AsyncClient s3AsyncClient, long bufferSizeInBytes, int maxInFlight) {
+    public DownloadObjectHelper(S3AsyncClient s3AsyncClient, long bufferSizeInBytes, int maxInFlightParts) {
         this.s3AsyncClient = s3AsyncClient;
         this.bufferSizeInBytes = bufferSizeInBytes;
-        this.maxInFlight = maxInFlight;
+        this.maxInFlightParts = maxInFlightParts;
     }
 
     public <T> CompletableFuture<T> downloadObject(
@@ -54,7 +54,7 @@ public <T> CompletableFuture<T> downloadObject(
             return downloadPartsSerially(getObjectRequest, split);
         }
 
-        return downloadPartsNonSerially(getObjectRequest, split, maxInFlight);
+        return downloadPartsNonSerially(getObjectRequest, split, maxInFlightParts);
 
     }
 

From 861d64d128499fe4e894e27abbe671246ba4625e Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 12:40:48 -0400
Subject: [PATCH 24/41] fix test utils after merge

---
 .../async/FileAsyncResponseTransformer.java         |  4 ----
 ...arMultipartDownloaderSubscriberWiremockTest.java | 13 +++++++------
 .../S3MultipartFileDownloadWiremockTest.java        |  7 ++++---
 .../amazon/awssdk/utils/ContentRangeParser.java     |  1 +
 4 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 4eba7a721136..826f480798ae 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -147,10 +147,6 @@ public void onResponse(ResponseT response) {
         this.response = response;
     }
 
-    public FileTransformerConfiguration getConfiguration() {
-        return this.configuration;
-    }
-
     @Override
     public void onStream(SdkPublisher<ByteBuffer> publisher) {
         try {
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
index d44d40011987..e95b79079927 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
@@ -39,6 +39,7 @@
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.S3Configuration;
+import software.amazon.awssdk.services.s3.internal.multipart.utils.MultipartDownloadTestUtils;
 import software.amazon.awssdk.services.s3.model.GetObjectRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
 
@@ -49,7 +50,7 @@ class NonLinearMultipartDownloaderSubscriberWiremockTest {
     private final String testKey = "test-key";
 
     private S3AsyncClient s3AsyncClient;
-    private MultipartDownloadTestUtil util;
+    private MultipartDownloadTestUtils utils;
     private FileSystem fileSystem;
     private Path testFile;
 
@@ -64,7 +65,7 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
                                                                           .pathStyleAccessEnabled(true)
                                                                           .build())
                                      .build();
-        util = new MultipartDownloadTestUtil(testBucket, testKey, "test-etag");
+        utils = new MultipartDownloadTestUtils(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
         testFile = fileSystem.getPath("/test-file.txt");
     }
@@ -78,7 +79,7 @@ void tearDown() throws Exception {
     @ValueSource(ints = {2, 3, 4, 5, 6, 7, 8, 9, 10})
     void happyPath_multipartDownload(int numParts) throws Exception {
         int partSize = 1024;
-        byte[] expectedBody = util.stubAllParts(testBucket, testKey, numParts, partSize);
+        byte[] expectedBody = utils.stubAllParts(testBucket, testKey, numParts, partSize);
 
         AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = AsyncResponseTransformer.toFile(testFile);
         AsyncResponseTransformer.SplitResult<GetObjectResponse, GetObjectResponse> split = transformer.split(
@@ -103,13 +104,13 @@ void happyPath_multipartDownload(int numParts) throws Exception {
         byte[] actualBody = Files.readAllBytes(testFile);
         assertThat(actualBody).isEqualTo(expectedBody);
         assertThat(getObjectResponse).isNotNull();
-        util.verifyCorrectAmountOfRequestsMade(numParts);
+        utils.verifyCorrectAmountOfRequestsMade(numParts);
     }
 
     @Test
     void singlePartObject_shouldCompleteWithoutMultipart() throws Exception {
         int partSize = 1024;
-        byte[] expectedBody = util.stubSinglePart(testBucket, testKey, partSize);
+        byte[] expectedBody = utils.stubSinglePart(testBucket, testKey, partSize);
 
         AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> transformer = AsyncResponseTransformer.toFile(testFile);
         AsyncResponseTransformer.SplitResult<GetObjectResponse, GetObjectResponse> split = transformer.split(
@@ -134,7 +135,7 @@ void singlePartObject_shouldCompleteWithoutMultipart() throws Exception {
         byte[] actualBody = Files.readAllBytes(testFile);
         assertThat(actualBody).isEqualTo(expectedBody);
         assertThat(getObjectResponse).isNotNull();
-        util.verifyCorrectAmountOfRequestsMade(1);
+        utils.verifyCorrectAmountOfRequestsMade(1);
     }
 
 }
\ No newline at end of file
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index 6a5199e683e3..fcc1a5cea5ed 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -23,7 +23,7 @@
 import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
 import static com.github.tomakehurst.wiremock.client.WireMock.verify;
 import static org.assertj.core.api.Assertions.assertThat;
-import static software.amazon.awssdk.services.s3.internal.multipart.MultipartDownloadTestUtil.contentRangeHeader;
+import static software.amazon.awssdk.services.s3.internal.multipart.utils.MultipartDownloadTestUtils.contentRangeHeader;
 
 import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
 import com.github.tomakehurst.wiremock.junit5.WireMockTest;
@@ -48,6 +48,7 @@
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.S3Configuration;
+import software.amazon.awssdk.services.s3.internal.multipart.utils.MultipartDownloadTestUtils;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
 import software.amazon.awssdk.services.s3.model.S3Exception;
 
@@ -58,7 +59,7 @@ class S3MultipartFileDownloadWiremockTest {
     private final String testKey = "test-key";
 
     private S3AsyncClient s3AsyncClient;
-    private MultipartDownloadTestUtil util;
+    private MultipartDownloadTestUtils util;
     private FileSystem fileSystem;
     private Path testFile;
 
@@ -81,7 +82,7 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
                                                                         .build())
                                      // .httpClient(AwsCrtAsyncHttpClient.create())
                                      .build();
-        util = new MultipartDownloadTestUtil(testBucket, testKey, "test-etag");
+        util = new MultipartDownloadTestUtils(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
         testFile = fileSystem.getPath("/test-file.txt");
     }
diff --git a/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
index f21dd1702b25..ae14a3bac7a5 100644
--- a/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
+++ b/utils/src/main/java/software/amazon/awssdk/utils/ContentRangeParser.java
@@ -109,6 +109,7 @@ public static Optional<Pair<Long, Long>> range(String contentRange) {
             long endInt = Long.parseLong(end);
             return Optional.of(Pair.of(startInt, endInt));
         } catch (Exception e) {
+            log.warn(() -> "failed to parse content range", e);
             return Optional.empty();
         }
     }

From c684d4c8d447681d770909e4f51bdb30ae88c657 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 12:47:38 -0400
Subject: [PATCH 25/41] remove comment code in test

---
 .../multipart/S3MultipartFileDownloadWiremockTest.java    | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index fcc1a5cea5ed..4e98555d03a9 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -44,7 +44,6 @@
 import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
-import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3AsyncClient;
 import software.amazon.awssdk.services.s3.S3Configuration;
@@ -74,13 +73,6 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
                                      .serviceConfiguration(S3Configuration.builder()
                                                                           .pathStyleAccessEnabled(true)
                                                                           .build())
-                                     .httpClient(NettyNioAsyncHttpClient.builder()
-                                                                        // .maxConcurrency(10_000)
-                                                                        // .connectionAcquisitionTimeout(Duration.ofSeconds(5))
-                                                                        // .connectionTimeout(Duration.ofSeconds(5))
-                                                                        // .connectionTimeToLive(Duration.ofSeconds(5))
-                                                                        .build())
-                                     // .httpClient(AwsCrtAsyncHttpClient.create())
                                      .build();
         util = new MultipartDownloadTestUtils(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());

From e34dcc334a0c89d7bbb21a62f4598eb9a6f7bbd4 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 13:03:18 -0400
Subject: [PATCH 26/41] checkstyle

---
 .../core/internal/async/FileAsyncResponseTransformer.java     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 826f480798ae..dbe3d76ff912 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -303,8 +303,8 @@ public String toString() {
     @Override
     public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
         if (configuration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
-            return AsyncResponseTransformer.super.
-                split(splitConfig)
+            return AsyncResponseTransformer.super
+                .split(splitConfig)
                 .copy(res -> res.supportsNonSerial(false));
         }
         return AsyncResponseTransformer.super

From 8506c43896f618909cb396b2257515e7f45fac7c Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 13:11:30 -0400
Subject: [PATCH 27/41] rename initialPosition to position

---
 .../core/internal/async/FileAsyncResponseTransformer.java       | 2 +-
 .../internal/async/FileAsyncResponseTransformerPublisher.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index dbe3d76ff912..a36ca90b5831 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -85,7 +85,7 @@ Path path() {
         return path;
     }
 
-    Long initialPosition() {
+    Long position() {
         return position;
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index c25d9f6bae3d..57a41d7c9603 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -54,7 +54,7 @@ public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
     public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> responseTransformer) {
         this.path = Validate.paramNotNull(responseTransformer.path(), "path");
         this.initialConfig = Validate.paramNotNull(responseTransformer.config(), "fileTransformerConfiguration");
-        this.initialPosition = responseTransformer.initialPosition();
+        this.initialPosition = responseTransformer.position();
         this.amountOfTransformerSent = new AtomicLong(0);
     }
 

From f3d3773e7ecc84e86d81cd5a5c1bc7779c333890 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 13:27:53 -0400
Subject: [PATCH 28/41] use firstMatchingHeader() instead of headers() in
 FileAsyncResponseTransformerPublisher to prevent copying all headers

---
 .../async/FileAsyncResponseTransformerPublisher.java     | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 57a41d7c9603..e110a0729fb1 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -17,7 +17,6 @@
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
-import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -28,12 +27,10 @@
 import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
-import software.amazon.awssdk.utils.CollectionUtils;
 import software.amazon.awssdk.utils.CompletableFutureUtils;
 import software.amazon.awssdk.utils.ContentRangeParser;
 import software.amazon.awssdk.utils.Logger;
 import software.amazon.awssdk.utils.Pair;
-import software.amazon.awssdk.utils.StringUtils;
 import software.amazon.awssdk.utils.Validate;
 
 /**
@@ -107,15 +104,15 @@ public CompletableFuture<T> prepare() {
 
         @Override
         public void onResponse(T response) {
-            List<String> contentRangeList = response.sdkHttpResponse().headers().get("x-amz-content-range");
-            if (CollectionUtils.isNullOrEmpty(contentRangeList) || StringUtils.isEmpty(contentRangeList.get(0))) {
+            Optional<String> contentRangeList = response.sdkHttpResponse().firstMatchingHeader("x-amz-content-range");
+            if (!contentRangeList.isPresent()) {
                 if (subscriber != null) {
                     subscriber.onError(new IllegalStateException("Content range header is missing"));
                 }
                 return;
             }
 
-            String contentRange = contentRangeList.get(0);
+            String contentRange = contentRangeList.get();
             Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
             if (!contentRangePair.isPresent()) {
                 if (subscriber != null) {

From e1360f757f89e6f940bbd49ab82bc61cb5498baa Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Tue, 16 Sep 2025 16:46:14 -0400
Subject: [PATCH 29/41] add handle error method

---
 ...onLinearMultipartDownloaderSubscriber.java | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 41815401f184..f5dc5d8f68c3 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -134,6 +134,8 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicInteger outstandingDemand = new AtomicInteger(0);
 
+    private final AtomicBoolean completedExceptionally = new AtomicBoolean(false);
+
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
                                                   GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture,
@@ -236,12 +238,10 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             inFlightRequests.remove(partToGet);
 
             completedParts.incrementAndGet();
-            if (e != null) {
+            if (e != null || completedExceptionally.get()) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
-                log.error(() -> "Error on part " + partToGet + ": " + e);
-                resultFuture.completeExceptionally(e);
-                inFlightRequests.values().forEach(future -> future.cancel(true));
+                handlePartError(e, partToGet);
                 return;
             }
             if (completedParts.get() >= totalParts) {
@@ -269,19 +269,16 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             inFlightRequests.remove(1);
 
             completedParts.incrementAndGet();
-            if (e != null) {
+            if (e != null || completedExceptionally.get()) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
-                resultFuture.completeExceptionally(e);
-                inFlightRequests.values().forEach(future -> future.cancel(true));
+                handlePartError(e, 1);
                 return;
             }
             Integer partCount = res.partsCount();
             eTag = res.eTag();
             if (partCount != null && totalParts == null) {
                 log.debug(() -> String.format("Total amount of parts of the object to download: %d", partCount));
-                // MultipartDownloadUtils.multipartDownloadResumeContext(getObjectRequest)
-                //                       .ifPresent(ctx -> ctx.totalParts(partCount));
                 totalParts = partCount;
             }
 
@@ -307,6 +304,13 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         });
     }
 
+    private void handlePartError(Throwable e, int part) {
+        completedExceptionally.set(true);
+        log.error(() -> "Error on part " + part + ": " + e);
+        resultFuture.completeExceptionally(e);
+        inFlightRequests.values().forEach(future -> future.cancel(true));
+    }
+
     private void processPendingTransformers() {
         synchronized (pendingTransformers) {
             int initialSize = pendingTransformers.size();

From d1db3c8ddffa11e5db8f805db4f43207343ea64a Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 13:04:51 -0400
Subject: [PATCH 30/41] fix FileAsyncResponseTransformerPublisherTest wrong
 content-range method mocking

---
 ...AsyncResponseTransformerPublisherTest.java | 30 +++++++------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index 42fa4d939ce6..0dcfada1d397 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -16,6 +16,7 @@
 package software.amazon.awssdk.core.internal.async;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -29,6 +30,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -64,10 +66,11 @@ void tearDown() throws Exception {
     @Test
     void happyPath_singleOnNext() throws Exception {
         // Given
-        AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
+        FileAsyncResponseTransformer<SdkResponse> initialTransformer =
+            (FileAsyncResponseTransformer<SdkResponse>) AsyncResponseTransformer.<SdkResponse>toFile(testFile);
 
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<?>) initialTransformer);
+            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
 
         CountDownLatch latch = new CountDownLatch(1);
         AtomicReference<AsyncResponseTransformer<SdkResponse, SdkResponse>> receivedTransformer = new AtomicReference<>();
@@ -79,16 +82,18 @@ void happyPath_singleOnNext() throws Exception {
 
             @Override
             public void onSubscribe(Subscription s) {
+                System.out.println("onSubscribe");
                 this.subscription = s;
                 s.request(1);
             }
 
             @Override
             public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transformer) {
+                System.out.println("onNext");
                 receivedTransformer.set(transformer);
 
                 // Simulate response with content-range header
-                SdkResponse mockResponse = createMockResponse();
+                SdkResponse mockResponse = createMockResponseWithRange("bytes 0-9/10");
                 CompletableFuture<SdkResponse> prepareFuture = transformer.prepare();
                 CompletableFutureUtils.forwardResultTo(prepareFuture, future);
                 transformer.onResponse(mockResponse);
@@ -102,11 +107,12 @@ public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transforme
 
             @Override
             public void onError(Throwable t) {
-                latch.countDown();
+                fail("Unexpected error with esception: " + t.getMessage());
             }
 
             @Override
             public void onComplete() {
+                System.out.println("onComplete");
                 latch.countDown();
             }
         });
@@ -118,18 +124,6 @@ public void onComplete() {
         assertThat(future).isCompleted();
     }
 
-    private SdkResponse createMockResponse() {
-        SdkResponse mockResponse = mock(SdkResponse.class);
-        SdkHttpResponse mockHttpResponse = mock(SdkHttpResponse.class);
-
-        when(mockResponse.sdkHttpResponse()).thenReturn(mockHttpResponse);
-        when(mockHttpResponse.headers()).thenReturn(
-            Collections.singletonMap("x-amz-content-range", Collections.singletonList("bytes 0-9/10"))
-        );
-
-        return mockResponse;
-    }
-
     private SdkPublisher<ByteBuffer> createMockPublisher() {
         return s -> s.onSubscribe(new Subscription() {
             @Override
@@ -225,9 +219,7 @@ private SdkResponse createMockResponseWithRange(String contentRange) {
         SdkHttpResponse mockHttpResponse = mock(SdkHttpResponse.class);
 
         when(mockResponse.sdkHttpResponse()).thenReturn(mockHttpResponse);
-        when(mockHttpResponse.headers()).thenReturn(
-            Collections.singletonMap("x-amz-content-range", Collections.singletonList(contentRange))
-        );
+        when(mockHttpResponse.firstMatchingHeader("x-amz-content-range")).thenReturn(Optional.of(contentRange));
 
         return mockResponse;
     }

From 50631f53cb37909f28c15b5825cd642308685cfb Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 13:29:19 -0400
Subject: [PATCH 31/41] use succeedsWithin assertion for future

---
 .../async/FileAsyncResponseTransformerPublisherTest.java        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index 0dcfada1d397..008366f1b485 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -121,7 +121,7 @@ public void onComplete() {
         assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue();
         assertThat(receivedTransformer.get()).isNotNull();
         assertThat(Files.exists(testFile)).isTrue();
-        assertThat(future).isCompleted();
+        assertThat(future).succeedsWithin(10, TimeUnit.SECONDS);
     }
 
     private SdkPublisher<ByteBuffer> createMockPublisher() {

From 8f36d185b2dfd4a37294c7a35c03fccb84460310 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 15:14:30 -0400
Subject: [PATCH 32/41] fix checkstyle violations

---
 .../multipart/NonLinearMultipartDownloaderSubscriber.java      | 3 ++-
 .../awssdk/services/s3/multipart/MultipartConfiguration.java   | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index f5dc5d8f68c3..7dcd7e956f94 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -178,7 +178,8 @@ public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse
         executeRequestOrAddToPending(asyncResponseTransformer);
     }
 
-    private void executeRequestOrAddToPending(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+    private void executeRequestOrAddToPending(
+        AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (handleFirstRequest(asyncResponseTransformer)) {
             return;
         }
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
index 2ef77be67a5a..f1d5ff35c60c 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/multipart/MultipartConfiguration.java
@@ -51,7 +51,7 @@ public final class MultipartConfiguration implements ToCopyableBuilder<Multipart
     private final Long thresholdInBytes;
     private final Long minimumPartSizeInBytes;
     private final Long apiCallBufferSizeInBytes;
-    private final ParallelConfiguration parallelConfiguration;;
+    private final ParallelConfiguration parallelConfiguration;
 
     private MultipartConfiguration(DefaultMultipartConfigBuilder builder) {
         this.thresholdInBytes = builder.thresholdInBytes;

From a1f8d23bb9445ac442a055cd097590978ce65e3f Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 15:15:59 -0400
Subject: [PATCH 33/41] fix checkstyle violations

---
 .../awssdk/transfer/s3/internal/GenericS3TransferManager.java  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
index b7e0a41cd1b7..a19df718c802 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
@@ -355,7 +355,8 @@ public final <ResultT> Download<ResultT> download(DownloadRequest<ResultT> downl
                     progressUpdater.wrapForNonSerialFileDownload(responseTransformer, downloadRequest.getObjectRequest());
             } else {
                 responseTransformer =
-                    progressUpdater.wrapResponseTransformerForMultipartDownload(responseTransformer, downloadRequest.getObjectRequest());
+                    progressUpdater.wrapResponseTransformerForMultipartDownload(
+                        responseTransformer, downloadRequest.getObjectRequest());
             }
         } else {
             responseTransformer = progressUpdater.wrapResponseTransformer(responseTransformer);

From 1716e46d4938144945736cef24a66c7ce8625255 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 23:32:54 -0400
Subject: [PATCH 34/41] PR comments - first pass

---
 .../async/FileAsyncResponseTransformer.java   | 13 +--
 ...FileAsyncResponseTransformerPublisher.java | 47 +++++------
 .../async/ThreadSafeEmittingSubscription.java | 66 +++++++++++++--
 ...AsyncResponseTransformerPublisherTest.java |  9 +-
 ...onLinearMultipartDownloaderSubscriber.java | 82 +++++++++++++------
 5 files changed, 148 insertions(+), 69 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index a36ca90b5831..a7e754b76ebc 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -85,7 +85,7 @@ Path path() {
         return path;
     }
 
-    Long position() {
+    long position() {
         return position;
     }
 
@@ -307,10 +307,11 @@ public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration
                 .split(splitConfig)
                 .copy(res -> res.supportsNonSerial(false));
         }
-        return AsyncResponseTransformer.super
-            .split(splitConfig)
-            .copy(
-                res -> res.supportsNonSerial(true)
-                          .publisher(new FileAsyncResponseTransformerPublisher(this)));
+        CompletableFuture<ResponseT> future = new CompletableFuture<>();
+        return (SplitResult<ResponseT, ResponseT>) SplitResult.<ResponseT, ResponseT>builder()
+                                                              .publisher(new FileAsyncResponseTransformerPublisher(this))
+                                                              .resultFuture(future)
+                                                              .supportsNonSerial(true)
+                                                              .build();
     }
 }
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index e110a0729fb1..068a17af4a72 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -45,14 +45,15 @@ public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
     private final Path path;
     private final FileTransformerConfiguration initialConfig;
     private final long initialPosition;
-    private final AtomicLong amountOfTransformerSent;
     private Subscriber<?> subscriber;
 
     public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> responseTransformer) {
         this.path = Validate.paramNotNull(responseTransformer.path(), "path");
+        Validate.isTrue(responseTransformer.config().fileWriteOption()
+                        != FileTransformerConfiguration.FileWriteOption.CREATE_OR_APPEND_TO_EXISTING,
+                        "CREATE_OR_APPEND_TO_EXISTING is not supported for non-serial operations");
         this.initialConfig = Validate.paramNotNull(responseTransformer.config(), "fileTransformerConfiguration");
         this.initialPosition = responseTransformer.position();
-        this.amountOfTransformerSent = new AtomicLong(0);
     }
 
     @Override
@@ -61,13 +62,12 @@ public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
             throw new NullPointerException("Subscription must not be null");
         }
         this.subscriber = s;
-        s.onSubscribe(new ThreadSafeEmittingSubscription<>(
-            s,
-            new AtomicLong(0),
-            this::onCancel,
-            new AtomicBoolean(),
-            log,
-            this::createTransformer));
+        s.onSubscribe(ThreadSafeEmittingSubscription.<AsyncResponseTransformer<T, T>>builder()
+                                                    .downstreamSubscriber(s)
+                                                    .onCancel(this::onCancel)
+                                                    .log(log)
+                                                    .supplier(this::createTransformer)
+                                                    .build());
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
@@ -107,7 +107,9 @@ public void onResponse(T response) {
             Optional<String> contentRangeList = response.sdkHttpResponse().firstMatchingHeader("x-amz-content-range");
             if (!contentRangeList.isPresent()) {
                 if (subscriber != null) {
-                    subscriber.onError(new IllegalStateException("Content range header is missing"));
+                    IllegalStateException e = new IllegalStateException("Content range header is missing");
+                    subscriber.onError(e);
+                    future.completeExceptionally(e);
                 }
                 return;
             }
@@ -116,7 +118,9 @@ public void onResponse(T response) {
             Optional<Pair<Long, Long>> contentRangePair = ContentRangeParser.range(contentRange);
             if (!contentRangePair.isPresent()) {
                 if (subscriber != null) {
-                    subscriber.onError(new IllegalStateException("Could not parse content range header " + contentRange));
+                    IllegalStateException e = new IllegalStateException("Could not parse content range header " + contentRange);
+                    subscriber.onError(e);
+                    future.completeExceptionally(e);
                 }
                 return;
             }
@@ -125,14 +129,10 @@ public void onResponse(T response) {
             CompletableFuture<T> delegateFuture = delegate.prepare();
             CompletableFutureUtils.forwardResultTo(delegateFuture, future);
             CompletableFutureUtils.forwardExceptionTo(future, delegateFuture);
-            amountOfTransformerSent.incrementAndGet();
             delegate.onResponse(response);
         }
 
         private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
-            if (amountOfTransformerSent.get() == 0) {
-                return AsyncResponseTransformer.toFile(path, initialConfig);
-            }
             switch (initialConfig.fileWriteOption()) {
                 case CREATE_NEW:
                 case CREATE_OR_REPLACE_EXISTING: {
@@ -141,11 +141,6 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
                         .position(startAt));
                     return AsyncResponseTransformer.toFile(path, newConfig);
                 }
-                case CREATE_OR_APPEND_TO_EXISTING: {
-                    // APPEND mode is not supported for non-serial operations,
-                    // we can just reuse the same config (with CREATE_OR_APPEND_TO_EXISTING) which will work serially
-                    return AsyncResponseTransformer.toFile(path, initialConfig);
-                }
                 case WRITE_TO_POSITION: {
                     long initialOffset = initialConfig.position();
                     FileTransformerConfiguration newConfig = initialConfig.copy(c -> c
@@ -153,6 +148,8 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
                         .position(initialOffset + startAt));
                     return AsyncResponseTransformer.toFile(path, newConfig);
                 }
+                // APPEND mode is not supported for non-serial operations,
+                case CREATE_OR_APPEND_TO_EXISTING:
                 default:
                     throw new UnsupportedOperationException("Unsupported fileWriteOption: " + initialConfig.fileWriteOption());
             }
@@ -160,10 +157,14 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
 
         @Override
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
-            if (delegate != null) {
-                // should never be null as per AsyncResponseTransformer runtime contract, but we never know
-                delegate.onStream(publisher);
+            // should never be null as per AsyncResponseTransformer runtime contract, but we never know
+            if (delegate == null) {
+               if (future != null) {
+                   future.completeExceptionally(new IllegalStateException("onStream called before onResponse"));
+               }
+               return;
             }
+            delegate.onStream(publisher);
         }
 
         @Override
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
index 6cff201e7a8a..8015035490dd 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
@@ -21,11 +21,13 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import software.amazon.awssdk.annotations.SdkInternalApi;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.utils.Logger;
 
 @SdkInternalApi
 public class ThreadSafeEmittingSubscription<T> implements Subscription {
 
+    private Subscriber<? super T> downstreamSubscriber;
     private final AtomicBoolean emitting = new AtomicBoolean(false);
     private final AtomicLong outstandingDemand;
     private final Runnable onCancel;
@@ -33,16 +35,18 @@ public class ThreadSafeEmittingSubscription<T> implements Subscription {
     private final Supplier<T> supplier;
     private final Logger log;
 
-    private Subscriber<T> downstreamSubscriber;
 
-    public ThreadSafeEmittingSubscription(Subscriber<T> downstreamSubscriber, AtomicLong outstandingDemand,
-                                          Runnable onCancel, AtomicBoolean isCancelled, Logger log, Supplier<T> supplier) {
-        this.downstreamSubscriber = downstreamSubscriber;
-        this.outstandingDemand = outstandingDemand;
-        this.onCancel = onCancel;
-        this.isCancelled = isCancelled;
-        this.log = log;
-        this.supplier = supplier;
+    private ThreadSafeEmittingSubscription(Builder<T> builder) {
+        this.downstreamSubscriber = builder.downstreamSubscriber;
+        this.outstandingDemand = builder.outstandingDemand;
+        this.onCancel = builder.onCancel;
+        this.isCancelled = builder.isCancelled;
+        this.log = builder.log;
+        this.supplier = builder.supplier;
+    }
+
+    public static <T> Builder<T> builder() {
+        return new Builder<>();
     }
 
     @Override
@@ -98,4 +102,48 @@ private boolean doEmit() {
         return false;
     }
 
+    public static class Builder<T> {
+        private Subscriber<? super T> downstreamSubscriber;
+        private AtomicLong outstandingDemand = new AtomicLong(0);
+        private AtomicBoolean isCancelled = new AtomicBoolean(false);
+        private Logger log = Logger.loggerFor(ThreadSafeEmittingSubscription.class);
+        private Runnable onCancel;
+        private Supplier<T> supplier;
+
+        public Builder<T> downstreamSubscriber(Subscriber<? super T> subscriber) {
+            this.downstreamSubscriber = subscriber;
+            return this;
+        }
+
+        public Builder<T> outstandingDemand(AtomicLong outstandingDemand) {
+            this.outstandingDemand = outstandingDemand;
+            return this;
+        }
+
+        public Builder<T> onCancel(Runnable onCancel) {
+            this.onCancel = onCancel;
+            return this;
+        }
+
+        public Builder<T> isCancelled(AtomicBoolean isCancelled) {
+            this.isCancelled = isCancelled;
+            return this;
+        }
+
+        public Builder<T> log(Logger log) {
+            this.log = log;
+            return this;
+        }
+
+        public Builder<T> supplier(Supplier<T> supplier) {
+            this.supplier = supplier;
+            return this;
+        }
+
+        public ThreadSafeEmittingSubscription<T> build() {
+            return new ThreadSafeEmittingSubscription<>(this);
+        }
+    }
+
+
 }
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index 008366f1b485..beae74119868 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -64,7 +64,7 @@ void tearDown() throws Exception {
     }
 
     @Test
-    void happyPath_singleOnNext() throws Exception {
+    void singleDemand_shouldEmitOneTransformer() throws Exception {
         // Given
         FileAsyncResponseTransformer<SdkResponse> initialTransformer =
             (FileAsyncResponseTransformer<SdkResponse>) AsyncResponseTransformer.<SdkResponse>toFile(testFile);
@@ -82,14 +82,12 @@ void happyPath_singleOnNext() throws Exception {
 
             @Override
             public void onSubscribe(Subscription s) {
-                System.out.println("onSubscribe");
                 this.subscription = s;
                 s.request(1);
             }
 
             @Override
             public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transformer) {
-                System.out.println("onNext");
                 receivedTransformer.set(transformer);
 
                 // Simulate response with content-range header
@@ -107,12 +105,11 @@ public void onNext(AsyncResponseTransformer<SdkResponse, SdkResponse> transforme
 
             @Override
             public void onError(Throwable t) {
-                fail("Unexpected error with esception: " + t.getMessage());
+                fail("Unexpected error with exception: " + t.getMessage());
             }
 
             @Override
             public void onComplete() {
-                System.out.println("onComplete");
                 latch.countDown();
             }
         });
@@ -139,7 +136,7 @@ public void cancel() {
     }
 
     @Test
-    void multipleOnNext_differentContentRanges() throws Exception {
+    void requestManyTransformers_withResponseContainingDifferentContentRanges_shouldWriteToFileAtThoseRanges() throws Exception {
         // Given
         AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 7dcd7e956f94..7e3a57a2bbf7 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -134,16 +134,21 @@ public class NonLinearMultipartDownloaderSubscriber
      */
     private final AtomicInteger outstandingDemand = new AtomicInteger(0);
 
+    /**
+     * Tracks if one of the parts requests future completed exceptionally. If this occurs, it means all retries were
+     * attempted for that part, but it still failed. This is a failure state, the error should be reported back to the user
+     * and any more request should be ignored.
+     */
     private final AtomicBoolean completedExceptionally = new AtomicBoolean(false);
 
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
                                                   GetObjectRequest getObjectRequest,
                                                   CompletableFuture<GetObjectResponse> resultFuture,
-                                                  int maxInFLight) {
+                                                  int maxInFlightParts) {
         this.s3 = s3;
         this.getObjectRequest = getObjectRequest;
         this.resultFuture = resultFuture;
-        this.maxInFlightParts = maxInFLight;
+        this.maxInFlightParts = maxInFlightParts;
     }
 
     @Override
@@ -185,7 +190,9 @@ private void executeRequestOrAddToPending(
         }
 
         if (inFlightRequests.size() >= maxInFlightParts) {
-            pendingTransformers.offer(asyncResponseTransformer);
+            synchronized (pendingTransformers) {
+                pendingTransformers.offer(asyncResponseTransformer);
+            }
             return;
         }
 
@@ -193,9 +200,11 @@ private void executeRequestOrAddToPending(
         requestMoreIfNeeded();
     }
 
-    // Handle first request.
-    // We need to wait for the first request to finish so we know if it is aa multipart object or not.
-    // While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
+    /**
+     * Handle first request.
+     * We need to wait for the first request to finish so we know if it is aa multipart object or not.
+     * While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
+     */
     private boolean handleFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (completedParts.get() != 0) {
             return false;
@@ -225,6 +234,9 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
         }
 
         Integer partToGet = nextPart();
+        if (partToGet == null) {
+            return;
+        }
 
         GetObjectRequest request = nextRequest(partToGet);
         log.debug(() -> "Sending next request for part: " + partToGet);
@@ -247,7 +259,11 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             }
             if (completedParts.get() >= totalParts) {
                 subscription.cancel();
-                resultFuture.complete(getObjectResponse);
+                if (completedParts.get() > totalParts) {
+                    resultFuture.completeExceptionally(new IllegalStateException("Total parts exceeded"));
+                } else {
+                    resultFuture.complete(getObjectResponse);
+                }
             } else {
                 processPendingTransformers();
                 requestMoreIfNeeded();
@@ -276,28 +292,16 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
                 handlePartError(e, 1);
                 return;
             }
-            Integer partCount = res.partsCount();
-            eTag = res.eTag();
-            if (partCount != null && totalParts == null) {
-                log.debug(() -> String.format("Total amount of parts of the object to download: %d", partCount));
-                totalParts = partCount;
-            }
 
-            // it is a multipart object?
-            if (totalParts == null || totalParts == 1) {
-                // Single part object detected, skip multipart and complete everything now
-                // todo change debug log
-                log.debug(() -> "Single Part object detected, skipping multipart download");
-                subscription.cancel();
-                resultFuture.complete(res);
+            setInitialPartCountAndEtag(res);
+
+            if (!isMultipartObject(res)) {
                 return;
             }
 
             log.debug(() -> "Multipart object detected, performing multipart download");
-            // part 1 already completed, so skip it
-            for (int i = 2; i <= totalParts; i++) {
-                allRemainingParts.add(i);
-            }
+            fillRemainingParts();
+
             getObjectResponse = res;
 
             processPendingTransformers();
@@ -305,6 +309,33 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
         });
     }
 
+    private void fillRemainingParts() {
+        // part 1 already completed, so skip it
+        for (int i = 2; i <= totalParts; i++) {
+            allRemainingParts.add(i);
+        }
+    }
+
+    private boolean isMultipartObject(GetObjectResponse response) {
+        if (totalParts == null || totalParts == 1) {
+            // Single part object detected, skip multipart and complete everything now
+            log.debug(() -> "Single Part object detected, skipping multipart download");
+            subscription.cancel();
+            resultFuture.complete(response);
+            return false;
+        }
+        return true;
+    }
+
+    private void setInitialPartCountAndEtag(GetObjectResponse response) {
+        Integer partCount = response.partsCount();
+        eTag = response.eTag();
+        if (partCount != null && totalParts == null) {
+            log.debug(() -> String.format("Total amount of parts of the object to download: %d", partCount));
+            totalParts = partCount;
+        }
+    }
+
     private void handlePartError(Throwable e, int part) {
         completedExceptionally.set(true);
         log.error(() -> "Error on part " + part + ": " + e);
@@ -384,7 +415,8 @@ public void onError(Throwable t) {
 
     @Override
     public void onComplete() {
-
+        // We check for completion state when we receive the GetObjectResponse for last part.
+        // This Subscriber is responsible for its completed state, so we do nothing here.
     }
 
     private GetObjectRequest nextRequest(int nextPartToGet) {

From 289554ec23d2590c914595e8d28dfa04dd8265df Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Wed, 17 Sep 2025 23:50:55 -0400
Subject: [PATCH 35/41] PR comments - keep transformerCount in
 FileAsyncResponseTransformerPublisher

---
 .../async/FileAsyncResponseTransformerPublisher.java      | 8 +++++++-
 .../async/FileAsyncResponseTransformerPublisherTest.java  | 4 +---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index 068a17af4a72..fdc4b3d5a018 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -19,7 +19,6 @@
 import java.nio.file.Path;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import org.reactivestreams.Subscriber;
 import software.amazon.awssdk.annotations.SdkInternalApi;
@@ -46,6 +45,8 @@ public class FileAsyncResponseTransformerPublisher<T extends SdkResponse>
     private final FileTransformerConfiguration initialConfig;
     private final long initialPosition;
     private Subscriber<?> subscriber;
+    private final AtomicLong transformerCount;
+
 
     public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> responseTransformer) {
         this.path = Validate.paramNotNull(responseTransformer.path(), "path");
@@ -54,6 +55,7 @@ public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> res
                         "CREATE_OR_APPEND_TO_EXISTING is not supported for non-serial operations");
         this.initialConfig = Validate.paramNotNull(responseTransformer.config(), "fileTransformerConfiguration");
         this.initialPosition = responseTransformer.position();
+        this.transformerCount = new AtomicLong(0);
     }
 
     @Override
@@ -129,10 +131,14 @@ public void onResponse(T response) {
             CompletableFuture<T> delegateFuture = delegate.prepare();
             CompletableFutureUtils.forwardResultTo(delegateFuture, future);
             CompletableFutureUtils.forwardExceptionTo(future, delegateFuture);
+            transformerCount.incrementAndGet();
             delegate.onResponse(response);
         }
 
         private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
+            if (transformerCount.get() == 0) {
+                return AsyncResponseTransformer.toFile(path, initialConfig);
+            }
             switch (initialConfig.fileWriteOption()) {
                 case CREATE_NEW:
                 case CREATE_OR_REPLACE_EXISTING: {
diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index beae74119868..28c8570e7def 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -20,7 +20,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import com.google.common.jimfs.Configuration;
 import com.google.common.jimfs.Jimfs;
 import java.nio.ByteBuffer;
 import java.nio.file.FileSystem;
@@ -28,7 +27,6 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
@@ -54,7 +52,7 @@ class FileAsyncResponseTransformerPublisherTest {
 
     @BeforeEach
     void setUp() throws Exception {
-        fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        fileSystem = Jimfs.newFileSystem();
         testFile = fileSystem.getPath("/test-file.txt");
     }
 

From e025fb38a8808837e0bfc3dd2b961d022bc0f303 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 18 Sep 2025 01:43:22 -0400
Subject: [PATCH 36/41] PR comments - keep transformerCount in
 FileAsyncResponseTransformerPublisher

---
 .../core/internal/async/FileAsyncResponseTransformer.java | 4 +---
 ...onLinearMultipartDownloaderSubscriberWiremockTest.java | 2 ++
 .../multipart/S3MultipartClientGetObjectWiremockTest.java | 8 ++++----
 .../multipart/S3MultipartFileDownloadWiremockTest.java    | 2 ++
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index a7e754b76ebc..82f14d8aa11e 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -303,9 +303,7 @@ public String toString() {
     @Override
     public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration splitConfig) {
         if (configuration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
-            return AsyncResponseTransformer.super
-                .split(splitConfig)
-                .copy(res -> res.supportsNonSerial(false));
+            return AsyncResponseTransformer.super.split(splitConfig);
         }
         CompletableFuture<ResponseT> future = new CompletableFuture<>();
         return (SplitResult<ResponseT, ResponseT>) SplitResult.<ResponseT, ResponseT>builder()
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
index e95b79079927..11cee2de933d 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberWiremockTest.java
@@ -68,6 +68,8 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
         utils = new MultipartDownloadTestUtils(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
         testFile = fileSystem.getPath("/test-file.txt");
+        Files.createDirectories(testFile.getParent());
+        Files.createFile(testFile);
     }
 
     @AfterEach
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartClientGetObjectWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartClientGetObjectWiremockTest.java
index 449f245203c9..7d4234b0ce5a 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartClientGetObjectWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartClientGetObjectWiremockTest.java
@@ -147,8 +147,9 @@ public <T> void errorOnThirdPart_shouldCompleteExceptionallyOnlyPartsGreaterThan
         }
     }
 
-    @ParameterizedTest
-    @MethodSource("partSizeAndTransformerParams")
+    // todo temporary, remove when support for resume is added to multipart file download
+    // @ParameterizedTest
+    // @MethodSource("partSizeAndTransformerParams")
     public <T> void partCountValidationFailure_shouldThrowException(
         AsyncResponseTransformerTestSupplier<T> supplier,
         int partSize) {
@@ -302,8 +303,7 @@ private static Stream<Arguments> partSizeAndTransformerParams() {
      */
     private static Stream<AsyncResponseTransformerTestSupplier<?>> nonRetryableResponseTransformers() {
         return Stream.of(new AsyncResponseTransformerTestSupplier.InputStreamArtSupplier(),
-                         new AsyncResponseTransformerTestSupplier.PublisherArtSupplier(),
-                         new AsyncResponseTransformerTestSupplier.FileArtSupplier());
+                         new AsyncResponseTransformerTestSupplier.PublisherArtSupplier());
     }
 
     private CompletableFuture<?> mock200Response(S3AsyncClient s3Client, int runNumber,
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
index 4e98555d03a9..0628129e42a4 100644
--- a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/S3MultipartFileDownloadWiremockTest.java
@@ -77,6 +77,8 @@ public void init(WireMockRuntimeInfo wiremock) throws Exception {
         util = new MultipartDownloadTestUtils(testBucket, testKey, "test-etag");
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
         testFile = fileSystem.getPath("/test-file.txt");
+        Files.createDirectories(testFile.getParent());
+        Files.createFile(testFile);
     }
 
     @AfterEach

From fe7985fd5726d0585f4bfee4ae47225b64e634df Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 18 Sep 2025 15:42:44 -0400
Subject: [PATCH 37/41] rename supportsNonSerial to parallelSplitSupported, and
 other PR comments - try/catch in ThreadSafeEmittingSubscription - negative
 totalParts check - NonLinearMultipartDownloaderSubscriberTckTest tck test

---
 .../core/async/AsyncResponseTransformer.java  |   6 +-
 ...ltAsyncResponseTransformerSplitResult.java |  22 ++--
 .../async/FileAsyncResponseTransformer.java   |   2 +-
 .../async/ThreadSafeEmittingSubscription.java |   9 +-
 .../s3/internal/GenericS3TransferManager.java |   3 +-
 .../multipart/DownloadObjectHelper.java       |   2 +-
 ...onLinearMultipartDownloaderSubscriber.java |   2 +-
 ...rMultipartDownloaderSubscriberTckTest.java | 117 ++++++++++++++++++
 8 files changed, 143 insertions(+), 20 deletions(-)
 create mode 100644 services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberTckTest.java

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
index b998d7711bbf..23e369ea7e03 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/async/AsyncResponseTransformer.java
@@ -386,7 +386,7 @@ interface SplitResult<ResponseT, ResultT>
          * receiving back data from the many {@link AsyncResponseTransformer#onStream(SdkPublisher) publishers} non-serially.
          * @return true if non-serial data is supported, false otherwise
          */
-        default Boolean supportsNonSerial() {
+        default Boolean parallelSplitSupported() {
             return false;
         }
 
@@ -428,14 +428,14 @@ interface Builder<ResponseT, ResultT>
              * parallel streaming of multiple content body concurrently.
              * @return
              */
-            Boolean supportsNonSerial();
+            Boolean parallelSplitSupported();
 
             /**
              * Sets whether the AsyncResponseTransformers returned by the {@link SplitResult#publisher()} support concurrent
              * parallel streaming of multiple content body concurrently
              * @return
              */
-            Builder<ResponseT, ResultT> supportsNonSerial(Boolean supportsParallel);
+            Builder<ResponseT, ResultT> parallelSplitSupported(Boolean parallelSplitSupported);
         }
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
index 8accd9355f85..0b095a34e973 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/DefaultAsyncResponseTransformerSplitResult.java
@@ -27,14 +27,14 @@ public final class DefaultAsyncResponseTransformerSplitResult<ResponseT, ResultT
 
     private final SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
     private final CompletableFuture<ResultT> future;
-    private final Boolean supportsNonSerial;
+    private final Boolean parallelSplitSupported;
 
     private DefaultAsyncResponseTransformerSplitResult(Builder<ResponseT, ResultT> builder) {
         this.publisher = Validate.paramNotNull(
             builder.publisher(), "asyncResponseTransformerPublisher");
         this.future = Validate.paramNotNull(
             builder.resultFuture(), "future");
-        this.supportsNonSerial = Validate.getOrDefault(builder.supportsNonSerial(), () -> false);
+        this.parallelSplitSupported = Validate.getOrDefault(builder.parallelSplitSupported(), () -> false);
     }
 
     /**
@@ -55,8 +55,8 @@ public CompletableFuture<ResultT> resultFuture() {
     }
 
     @Override
-    public Boolean supportsNonSerial() {
-        return this.supportsNonSerial;
+    public Boolean parallelSplitSupported() {
+        return this.parallelSplitSupported;
     }
 
     @Override
@@ -72,7 +72,7 @@ public static class DefaultBuilder<ResponseT, ResultT>
         implements AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> {
         private SdkPublisher<AsyncResponseTransformer<ResponseT, ResponseT>> publisher;
         private CompletableFuture<ResultT> future;
-        private Boolean supportsNonSerial;
+        private Boolean parallelSplitSupported;
 
         DefaultBuilder() {
         }
@@ -80,7 +80,7 @@ public static class DefaultBuilder<ResponseT, ResultT>
         DefaultBuilder(DefaultAsyncResponseTransformerSplitResult<ResponseT, ResultT> split) {
             this.publisher = split.publisher;
             this.future = split.future;
-            this.supportsNonSerial = split.supportsNonSerial;
+            this.parallelSplitSupported = split.parallelSplitSupported;
         }
 
         @Override
@@ -108,14 +108,14 @@ public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> resultFu
         }
 
         @Override
-        public Boolean supportsNonSerial() {
-            return supportsNonSerial;
+        public Boolean parallelSplitSupported() {
+            return parallelSplitSupported;
         }
 
         @Override
-        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> supportsNonSerial(
-            Boolean supportsParallel) {
-            this.supportsNonSerial = supportsParallel;
+        public AsyncResponseTransformer.SplitResult.Builder<ResponseT, ResultT> parallelSplitSupported(
+            Boolean parallelSplitSupported) {
+            this.parallelSplitSupported = parallelSplitSupported;
             return this;
         }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
index 82f14d8aa11e..dd915f90f293 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java
@@ -309,7 +309,7 @@ public SplitResult<ResponseT, ResponseT> split(SplittingTransformerConfiguration
         return (SplitResult<ResponseT, ResponseT>) SplitResult.<ResponseT, ResponseT>builder()
                                                               .publisher(new FileAsyncResponseTransformerPublisher(this))
                                                               .resultFuture(future)
-                                                              .supportsNonSerial(true)
+                                                              .parallelSplitSupported(true)
                                                               .build();
     }
 }
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
index 8015035490dd..b3b0019ecd3c 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
@@ -96,7 +96,14 @@ private boolean doEmit() {
             }
             if (outstandingDemand.get() > 0) {
                 demand = outstandingDemand.decrementAndGet();
-                downstreamSubscriber.onNext(supplier.get());
+                T value;
+                try {
+                    value = supplier.get();
+                } catch (Exception e) {
+                    downstreamSubscriber.onError(e);
+                    return true;
+                }
+                downstreamSubscriber.onNext(value);
             }
         }
         return false;
diff --git a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
index a19df718c802..f65cabec1ee3 100644
--- a/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
+++ b/services-custom/s3-transfer-manager/src/main/java/software/amazon/awssdk/transfer/s3/internal/GenericS3TransferManager.java
@@ -349,8 +349,7 @@ public final <ResultT> Download<ResultT> download(DownloadRequest<ResultT> downl
         TransferProgressUpdater progressUpdater = new TransferProgressUpdater(downloadRequest, null);
         progressUpdater.transferInitiated();
         if (isS3ClientMultipartEnabled()) {
-            // TODO find a better way to do that
-            if (responseTransformer.split(b -> b.bufferSizeInBytes(1L)).supportsNonSerial()) {
+            if (responseTransformer.split(b -> b.bufferSizeInBytes(1L)).parallelSplitSupported()) {
                 responseTransformer =
                     progressUpdater.wrapForNonSerialFileDownload(responseTransformer, downloadRequest.getObjectRequest());
             } else {
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
index 9b56801fa930..268f096dca27 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/DownloadObjectHelper.java
@@ -50,7 +50,7 @@ public <T> CompletableFuture<T> downloadObject(
             asyncResponseTransformer.split(SplittingTransformerConfiguration.builder()
                                                                             .bufferSizeInBytes(bufferSizeInBytes)
                                                                             .build());
-        if (!split.supportsNonSerial()) {
+        if (!split.parallelSplitSupported()) {
             return downloadPartsSerially(getObjectRequest, split);
         }
 
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 7e3a57a2bbf7..d910dce69540 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -317,7 +317,7 @@ private void fillRemainingParts() {
     }
 
     private boolean isMultipartObject(GetObjectResponse response) {
-        if (totalParts == null || totalParts == 1) {
+        if (totalParts == null || totalParts <= 1) {
             // Single part object detected, skip multipart and complete everything now
             log.debug(() -> "Single Part object detected, skipping multipart download");
             subscription.cancel();
diff --git a/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberTckTest.java b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberTckTest.java
new file mode 100644
index 000000000000..45fe07f05037
--- /dev/null
+++ b/services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriberTckTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.services.s3.internal.multipart;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletableFuture;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import org.reactivestreams.tck.SubscriberWhiteboxVerification;
+import org.reactivestreams.tck.TestEnvironment;
+import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.core.async.SdkPublisher;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+
+public class NonLinearMultipartDownloaderSubscriberTckTest
+    extends SubscriberWhiteboxVerification<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> {
+    private S3AsyncClient s3Client;
+    private CompletableFuture<GetObjectResponse> future;
+
+    public NonLinearMultipartDownloaderSubscriberTckTest() {
+        super(new TestEnvironment());
+        s3Client = mock(S3AsyncClient.class);
+        when(s3Client.getObject(any(GetObjectRequest.class), any(AsyncResponseTransformer.class)))
+            .thenReturn(CompletableFuture.completedFuture(GetObjectResponse.builder()
+                                                                           .partsCount(10)
+                                                                           .eTag("eTag")
+                                                                           .build()));
+        future = new CompletableFuture<>();
+    }
+
+    @Override
+    public Subscriber<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> createSubscriber(
+        WhiteboxSubscriberProbe<AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>> probe) {
+        return new NonLinearMultipartDownloaderSubscriber(s3Client, GetObjectRequest.builder().build(), future, 50) {
+            @Override
+            public void onSubscribe(Subscription s) {
+                super.onSubscribe(s);
+                probe.registerOnSubscribe(new SubscriberWhiteboxVerification.SubscriberPuppet() {
+
+                    @Override
+                    public void triggerRequest(long l) {
+                        s.request(l);
+                    }
+
+                    @Override
+                    public void signalCancel() {
+                        s.cancel();
+                    }
+                });
+            }
+
+            @Override
+            public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> item) {
+                super.onNext(item);
+                probe.registerOnNext(item);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                super.onError(t);
+                probe.registerOnError(t);
+            }
+
+            @Override
+            public void onComplete() {
+                super.onComplete();
+                probe.registerOnComplete();
+            }
+
+        };
+    }
+
+    @Override
+    public AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> createElement(int element) {
+        return new AsyncResponseTransformer<GetObjectResponse, GetObjectResponse>() {
+            @Override
+            public CompletableFuture<GetObjectResponse> prepare() {
+                return new CompletableFuture<>();
+            }
+
+            @Override
+            public void onResponse(GetObjectResponse response) {
+                // do nothing, test
+            }
+
+            @Override
+            public void onStream(SdkPublisher<ByteBuffer> publisher) {
+                // do nothing, test
+            }
+
+            @Override
+            public void exceptionOccurred(Throwable error) {
+                // do nothing, test
+            }
+        };
+    }
+}
\ No newline at end of file

From af94ef13ea2ba93e021c525bb3b5616d0ece02e1 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 18 Sep 2025 16:39:12 -0400
Subject: [PATCH 38/41] Added file config options to
 FileAsyncResponseTransformerPublisherTest

---
 ...AsyncResponseTransformerPublisherTest.java | 96 ++++++++++++++++---
 1 file changed, 83 insertions(+), 13 deletions(-)

diff --git a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
index 28c8570e7def..adfd4ecc3200 100644
--- a/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
+++ b/core/sdk-core/src/test/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisherTest.java
@@ -16,7 +16,9 @@
 package software.amazon.awssdk.core.internal.async;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.in;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -29,16 +31,23 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
+import software.amazon.awssdk.core.FileTransformerConfiguration;
 import software.amazon.awssdk.core.SdkResponse;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.async.SdkPublisher;
@@ -53,7 +62,7 @@ class FileAsyncResponseTransformerPublisherTest {
     @BeforeEach
     void setUp() throws Exception {
         fileSystem = Jimfs.newFileSystem();
-        testFile = fileSystem.getPath("/test-file.txt");
+        testFile = fileSystem.getPath(String.format("/test-file-%s.txt", UUID.randomUUID()));
     }
 
     @AfterEach
@@ -61,14 +70,19 @@ void tearDown() throws Exception {
         fileSystem.close();
     }
 
-    @Test
-    void singleDemand_shouldEmitOneTransformer() throws Exception {
+    @ParameterizedTest
+    @MethodSource("transformers")
+    void singleDemand_shouldEmitOneTransformer(
+        Function<Path, AsyncResponseTransformer<SdkResponse, SdkResponse>> transformerFunction) throws Exception {
         // Given
-        FileAsyncResponseTransformer<SdkResponse> initialTransformer =
-            (FileAsyncResponseTransformer<SdkResponse>) AsyncResponseTransformer.<SdkResponse>toFile(testFile);
+        // FileAsyncResponseTransformer<SdkResponse> initialTransformer =
+        //     (FileAsyncResponseTransformer<SdkResponse>) AsyncResponseTransformer.<SdkResponse>toFile(testFile);
+
+        AsyncResponseTransformer<SdkResponse, SdkResponse> initialTransformer = transformerFunction.apply(testFile);
+        createFileIfNeeded(initialTransformer);
 
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
+            new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<SdkResponse>) initialTransformer);
 
         CountDownLatch latch = new CountDownLatch(1);
         AtomicReference<AsyncResponseTransformer<SdkResponse, SdkResponse>> receivedTransformer = new AtomicReference<>();
@@ -119,6 +133,14 @@ public void onComplete() {
         assertThat(future).succeedsWithin(10, TimeUnit.SECONDS);
     }
 
+    private void createFileIfNeeded(AsyncResponseTransformer<SdkResponse, SdkResponse> initialTransformer) throws Exception {
+        FileTransformerConfiguration.FileWriteOption fileWriteOption =
+            ((FileAsyncResponseTransformer<SdkResponse>) initialTransformer).config().fileWriteOption();
+        if (fileWriteOption == FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION) {
+            Files.createFile(testFile);
+        }
+    }
+
     private SdkPublisher<ByteBuffer> createMockPublisher() {
         return s -> s.onSubscribe(new Subscription() {
             @Override
@@ -133,12 +155,18 @@ public void cancel() {
         });
     }
 
-    @Test
-    void requestManyTransformers_withResponseContainingDifferentContentRanges_shouldWriteToFileAtThoseRanges() throws Exception {
+    @ParameterizedTest
+    @MethodSource("transformers")
+    void requestManyTransformers_withResponseContainingDifferentContentRanges_shouldWriteToFileAtThoseRanges(
+        Function<Path, AsyncResponseTransformer<SdkResponse, SdkResponse>> transformerFunction
+    ) throws Exception {
         // Given
-        AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(testFile);
+        FileAsyncResponseTransformer<SdkResponse> initialTransformer =
+            (FileAsyncResponseTransformer<SdkResponse>) transformerFunction.apply(testFile);
+        createFileIfNeeded(initialTransformer);
+
         FileAsyncResponseTransformerPublisher<SdkResponse> publisher =
-            new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<?>) initialTransformer);
+            new FileAsyncResponseTransformerPublisher<>(initialTransformer);
 
         int numTransformers = 8;
         CountDownLatch latch = new CountDownLatch(numTransformers);
@@ -196,15 +224,18 @@ public void onComplete() {
         assertThat(Files.exists(testFile)).isTrue();
         byte[] fileContent = Files.readAllBytes(testFile);
 
-        assertThat(fileContent.length).isEqualTo(80);
-
+        int offset =
+            initialTransformer.config().fileWriteOption() == FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION
+            ? (int) initialTransformer.position()
+            : 0;
+        assertThat(fileContent.length).isEqualTo(80 + offset);
         for (int i = 0; i < numTransformers; i++) {
             int startPos = i * 10;
             byte[] expectedData = new byte[10];
             for (int j = 0; j < 10; j++) {
                 expectedData[j] = (byte) ((byte) startPos + j);
             }
-            byte[] actualData = Arrays.copyOfRange(fileContent, startPos, startPos + 10);
+            byte[] actualData = Arrays.copyOfRange(fileContent, startPos + offset, startPos + offset + 10);
             assertThat(actualData).isEqualTo(expectedData);
         }
     }
@@ -233,4 +264,43 @@ public void cancel() {
         });
     }
 
+    private static Stream<Function<Path, AsyncResponseTransformer<SdkResponse, SdkResponse>>> transformers() {
+        return Stream.of(
+            AsyncResponseTransformer::toFile,
+            path -> AsyncResponseTransformer.toFile(
+                path,
+                FileTransformerConfiguration.builder()
+                                            .fileWriteOption(FileTransformerConfiguration.FileWriteOption.CREATE_NEW)
+                                            .failureBehavior(FileTransformerConfiguration.FailureBehavior.LEAVE)
+                                            .build()),
+            path -> AsyncResponseTransformer.toFile(
+                path,
+                FileTransformerConfiguration.builder()
+                                            .fileWriteOption(FileTransformerConfiguration.FileWriteOption.CREATE_OR_REPLACE_EXISTING)
+                                            .failureBehavior(FileTransformerConfiguration.FailureBehavior.LEAVE)
+                                            .build()),
+            path -> AsyncResponseTransformer.toFile(
+                path,
+                FileTransformerConfiguration.builder()
+                                            .fileWriteOption(FileTransformerConfiguration.FileWriteOption.WRITE_TO_POSITION)
+                                            .failureBehavior(FileTransformerConfiguration.FailureBehavior.LEAVE)
+                                            .position(10L)
+                                            .build())
+        );
+    }
+
+    @Test
+    void createOrAppendToExisting_shouldThrowException() throws Exception {
+        AsyncResponseTransformer<Object, Object> initialTransformer = AsyncResponseTransformer.toFile(
+            testFile,
+            FileTransformerConfiguration.builder()
+                                        .failureBehavior(FileTransformerConfiguration.FailureBehavior.DELETE)
+                                        .fileWriteOption(FileTransformerConfiguration.FileWriteOption.CREATE_OR_APPEND_TO_EXISTING)
+                                        .build());
+        assertThatThrownBy(() -> new FileAsyncResponseTransformerPublisher<>((FileAsyncResponseTransformer<?>) initialTransformer))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("CREATE_OR_APPEND_TO_EXISTING");
+
+    }
+
 }
\ No newline at end of file

From 9902ec867d7640c7be778cdee7c066de7f3133d3 Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Thu, 18 Sep 2025 17:56:03 -0400
Subject: [PATCH 39/41] PR comments - renamed EmittingSubscription, mark it
 ThreadSafe - Added comments - some other renaming

---
 ...ription.java => EmittingSubscription.java} | 19 ++++++++----
 ...FileAsyncResponseTransformerPublisher.java | 29 ++++++++++---------
 .../MultipartConfigurationResolver.java       |  2 ++
 ...onLinearMultipartDownloaderSubscriber.java | 18 ++++++------
 4 files changed, 39 insertions(+), 29 deletions(-)
 rename core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/{ThreadSafeEmittingSubscription.java => EmittingSubscription.java} (86%)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/EmittingSubscription.java
similarity index 86%
rename from core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
rename to core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/EmittingSubscription.java
index b3b0019ecd3c..e7022f2d0e38 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ThreadSafeEmittingSubscription.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/EmittingSubscription.java
@@ -21,11 +21,18 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import software.amazon.awssdk.annotations.SdkInternalApi;
-import software.amazon.awssdk.core.async.AsyncResponseTransformer;
+import software.amazon.awssdk.annotations.ThreadSafe;
 import software.amazon.awssdk.utils.Logger;
 
+/**
+ * Subscription which can emit {@link Subscriber#onNext(T)} signals to a subscriber, based on the demand received with the
+ * {@link Subscription#request(long)}. It tracks the outstandingDemand that has not yet been fulfilled and used a Supplier
+ * passed to it to create the object it needs to emit.
+ * @param <T> the type of obejct to emit to the subscriber.
+ */
 @SdkInternalApi
-public class ThreadSafeEmittingSubscription<T> implements Subscription {
+@ThreadSafe
+public final class EmittingSubscription<T> implements Subscription {
 
     private Subscriber<? super T> downstreamSubscriber;
     private final AtomicBoolean emitting = new AtomicBoolean(false);
@@ -36,7 +43,7 @@ public class ThreadSafeEmittingSubscription<T> implements Subscription {
     private final Logger log;
 
 
-    private ThreadSafeEmittingSubscription(Builder<T> builder) {
+    private EmittingSubscription(Builder<T> builder) {
         this.downstreamSubscriber = builder.downstreamSubscriber;
         this.outstandingDemand = builder.outstandingDemand;
         this.onCancel = builder.onCancel;
@@ -113,7 +120,7 @@ public static class Builder<T> {
         private Subscriber<? super T> downstreamSubscriber;
         private AtomicLong outstandingDemand = new AtomicLong(0);
         private AtomicBoolean isCancelled = new AtomicBoolean(false);
-        private Logger log = Logger.loggerFor(ThreadSafeEmittingSubscription.class);
+        private Logger log = Logger.loggerFor(EmittingSubscription.class);
         private Runnable onCancel;
         private Supplier<T> supplier;
 
@@ -147,8 +154,8 @@ public Builder<T> supplier(Supplier<T> supplier) {
             return this;
         }
 
-        public ThreadSafeEmittingSubscription<T> build() {
-            return new ThreadSafeEmittingSubscription<>(this);
+        public EmittingSubscription<T> build() {
+            return new EmittingSubscription<>(this);
         }
     }
 
diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index fdc4b3d5a018..c222b3080a54 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -60,16 +60,14 @@ public FileAsyncResponseTransformerPublisher(FileAsyncResponseTransformer<?> res
 
     @Override
     public void subscribe(Subscriber<? super AsyncResponseTransformer<T, T>> s) {
-        if (s == null) {
-            throw new NullPointerException("Subscription must not be null");
-        }
+        Validate.notNull(s, "Subscriber must not be null");
         this.subscriber = s;
-        s.onSubscribe(ThreadSafeEmittingSubscription.<AsyncResponseTransformer<T, T>>builder()
-                                                    .downstreamSubscriber(s)
-                                                    .onCancel(this::onCancel)
-                                                    .log(log)
-                                                    .supplier(this::createTransformer)
-                                                    .build());
+        s.onSubscribe(EmittingSubscription.<AsyncResponseTransformer<T, T>>builder()
+                                          .downstreamSubscriber(s)
+                                          .onCancel(this::onCancel)
+                                          .log(log)
+                                          .supplier(this::createTransformer)
+                                          .build());
     }
 
     private AsyncResponseTransformer<T, T> createTransformer() {
@@ -110,8 +108,7 @@ public void onResponse(T response) {
             if (!contentRangeList.isPresent()) {
                 if (subscriber != null) {
                     IllegalStateException e = new IllegalStateException("Content range header is missing");
-                    subscriber.onError(e);
-                    future.completeExceptionally(e);
+                    handleError(e);
                 }
                 return;
             }
@@ -121,8 +118,7 @@ public void onResponse(T response) {
             if (!contentRangePair.isPresent()) {
                 if (subscriber != null) {
                     IllegalStateException e = new IllegalStateException("Could not parse content range header " + contentRange);
-                    subscriber.onError(e);
-                    future.completeExceptionally(e);
+                    handleError(e);
                 }
                 return;
             }
@@ -135,6 +131,11 @@ public void onResponse(T response) {
             delegate.onResponse(response);
         }
 
+        private void handleError(Throwable e) {
+            subscriber.onError(e);
+            future.completeExceptionally(e);
+        }
+
         private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
             if (transformerCount.get() == 0) {
                 return AsyncResponseTransformer.toFile(path, initialConfig);
@@ -154,7 +155,7 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
                         .position(initialOffset + startAt));
                     return AsyncResponseTransformer.toFile(path, newConfig);
                 }
-                // APPEND mode is not supported for non-serial operations,
+                // As per design specification, APPEND mode is not supported for non-serial operations
                 case CREATE_OR_APPEND_TO_EXISTING:
                 default:
                     throw new UnsupportedOperationException("Unsupported fileWriteOption: " + initialConfig.fileWriteOption());
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
index 6d8358e72efa..d5a302362b26 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/MultipartConfigurationResolver.java
@@ -27,6 +27,8 @@
 public final class MultipartConfigurationResolver {
 
     private static final long DEFAULT_MIN_PART_SIZE = 8L * 1024 * 1024;
+
+    // Using 50 as the default since maxConcurrency for http client is also 50
     private static final int DEFAULT_MAX_IN_FLIGHT_PARTS = 50;
 
     private final long minimalPartSizeInBytes;
diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index d910dce69540..27fed79d8834 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -122,7 +122,7 @@ public class NonLinearMultipartDownloaderSubscriber
     /**
      * Tracks if the first request was sent
      */
-    private final AtomicBoolean firstRequestSent = new AtomicBoolean(false);
+    private final AtomicBoolean isFirstRequestSent = new AtomicBoolean(false);
 
     /**
      * Tracks the total number of transformers requested from the subscription
@@ -139,7 +139,7 @@ public class NonLinearMultipartDownloaderSubscriber
      * attempted for that part, but it still failed. This is a failure state, the error should be reported back to the user
      * and any more request should be ignored.
      */
-    private final AtomicBoolean completedExceptionally = new AtomicBoolean(false);
+    private final AtomicBoolean isCompletedExceptionally = new AtomicBoolean(false);
 
     public NonLinearMultipartDownloaderSubscriber(S3AsyncClient s3,
                                                   GetObjectRequest getObjectRequest,
@@ -185,7 +185,7 @@ public void onNext(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse
 
     private void executeRequestOrAddToPending(
         AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
-        if (handleFirstRequest(asyncResponseTransformer)) {
+        if (handleFirstRequestOrEnqueueTransformer(asyncResponseTransformer)) {
             return;
         }
 
@@ -205,16 +205,16 @@ private void executeRequestOrAddToPending(
      * We need to wait for the first request to finish so we know if it is aa multipart object or not.
      * While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
      */
-    private boolean handleFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+    private boolean handleFirstRequestOrEnqueueTransformer(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (completedParts.get() != 0) {
             return false;
         }
 
         firstPartLock.lock();
         try {
-            if (!firstRequestSent.get()) {
+            if (!isFirstRequestSent.get()) {
                 sendFirstRequest(asyncResponseTransformer);
-                firstRequestSent.set(true);
+                isFirstRequestSent.set(true);
                 return true;
             }
 
@@ -251,7 +251,7 @@ private void sendNextRequest(AsyncResponseTransformer<GetObjectResponse, GetObje
             inFlightRequests.remove(partToGet);
 
             completedParts.incrementAndGet();
-            if (e != null || completedExceptionally.get()) {
+            if (e != null || isCompletedExceptionally.get()) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
                 handlePartError(e, partToGet);
@@ -286,7 +286,7 @@ private void sendFirstRequest(AsyncResponseTransformer<GetObjectResponse, GetObj
             inFlightRequests.remove(1);
 
             completedParts.incrementAndGet();
-            if (e != null || completedExceptionally.get()) {
+            if (e != null || isCompletedExceptionally.get()) {
                 // Note on retries: When this future completes exceptionally, it means we did all retries and still failed for
                 // that part. We need to report back the failure to the user.
                 handlePartError(e, 1);
@@ -337,7 +337,7 @@ private void setInitialPartCountAndEtag(GetObjectResponse response) {
     }
 
     private void handlePartError(Throwable e, int part) {
-        completedExceptionally.set(true);
+        isCompletedExceptionally.set(true);
         log.error(() -> "Error on part " + part + ": " + e);
         resultFuture.completeExceptionally(e);
         inFlightRequests.values().forEach(future -> future.cancel(true));

From e6c824c63e2ae1f55d0d34b6be6a608a86dd948e Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 19 Sep 2025 11:21:37 -0400
Subject: [PATCH 40/41] checkstyle

---
 .../async/FileAsyncResponseTransformerPublisher.java      | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
index c222b3080a54..09583f179cf5 100644
--- a/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
+++ b/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformerPublisher.java
@@ -166,10 +166,10 @@ private AsyncResponseTransformer<T, T> getDelegateTransformer(Long startAt) {
         public void onStream(SdkPublisher<ByteBuffer> publisher) {
             // should never be null as per AsyncResponseTransformer runtime contract, but we never know
             if (delegate == null) {
-               if (future != null) {
-                   future.completeExceptionally(new IllegalStateException("onStream called before onResponse"));
-               }
-               return;
+                if (future != null) {
+                    future.completeExceptionally(new IllegalStateException("onStream called before onResponse"));
+                }
+                return;
             }
             delegate.onStream(publisher);
         }

From 13098d3fd9de3aa7c2dc8ec2f3fe52981172dc2a Mon Sep 17 00:00:00 2001
From: Olivier Lepage-Applin <olapplin@amazon.com>
Date: Fri, 19 Sep 2025 12:40:07 -0400
Subject: [PATCH 41/41] checkstyle

---
 .../multipart/NonLinearMultipartDownloaderSubscriber.java      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
index 27fed79d8834..8e15bed2a08b 100644
--- a/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
+++ b/services/s3/src/main/java/software/amazon/awssdk/services/s3/internal/multipart/NonLinearMultipartDownloaderSubscriber.java
@@ -205,7 +205,8 @@ private void executeRequestOrAddToPending(
      * We need to wait for the first request to finish so we know if it is aa multipart object or not.
      * While we don't know yet, additional onNext signal receives are stored in pendingTransformers.
      */
-    private boolean handleFirstRequestOrEnqueueTransformer(AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
+    private boolean handleFirstRequestOrEnqueueTransformer(
+        AsyncResponseTransformer<GetObjectResponse, GetObjectResponse> asyncResponseTransformer) {
         if (completedParts.get() != 0) {
             return false;
         }