aws-sdk-s3 1.198.0 → 1.202.0

data/lib/aws-sdk-s3/multipart_stream_uploader.rb

@@ -11,7 +11,6 @@ module Aws
     class MultipartStreamUploader
 
       DEFAULT_PART_SIZE = 5 * 1024 * 1024 # 5MB
-      DEFAULT_THREAD_COUNT = 10
       CREATE_OPTIONS = Set.new(Client.api.operation(:create_multipart_upload).input.shape.member_names)
       UPLOAD_PART_OPTIONS = Set.new(Client.api.operation(:upload_part).input.shape.member_names)
       COMPLETE_UPLOAD_OPTIONS = Set.new(Client.api.operation(:complete_multipart_upload).input.shape.member_names)
@@ -19,9 +18,9 @@ module Aws
       # @option options [Client] :client
       def initialize(options = {})
         @client = options[:client] || Client.new
+        @executor = options[:executor]
         @tempfile = options[:tempfile]
         @part_size = options[:part_size] || DEFAULT_PART_SIZE
-        @thread_count = options[:thread_count] || DEFAULT_THREAD_COUNT
       end
 
       # @return [Client]
@@ -29,7 +28,6 @@ module Aws
 
       # @option options [required,String] :bucket
       # @option options [required,String] :key
-      # @option options [Integer] :thread_count (DEFAULT_THREAD_COUNT)
       # @return [Seahorse::Client::Response] - the CompleteMultipartUploadResponse
       def upload(options = {}, &block)
         Aws::Plugins::UserAgent.metric('S3_TRANSFER') do
@@ -54,28 +52,30 @@ module Aws
       end
 
       def upload_parts(upload_id, options, &block)
-        completed = Queue.new
-        thread_errors = []
-        errors = begin
+        completed_parts = Queue.new
+        errors = []
+
+        begin
           IO.pipe do |read_pipe, write_pipe|
-            threads = upload_in_threads(
-              read_pipe,
-              completed,
-              upload_part_opts(options).merge(upload_id: upload_id),
-              thread_errors
-            )
-            begin
-              block.call(write_pipe)
-            ensure
-              # Ensure the pipe is closed to avoid https://github.com/jruby/jruby/issues/6111
-              write_pipe.close
+            upload_thread = Thread.new do
+              upload_with_executor(
+                read_pipe,
+                completed_parts,
+                errors,
+                upload_part_opts(options).merge(upload_id: upload_id)
+              )
             end
-            threads.map(&:value).compact
+
+            block.call(write_pipe)
+          ensure
+            # Ensure the pipe is closed to avoid https://github.com/jruby/jruby/issues/6111
+            write_pipe.close
+            upload_thread.join
           end
         rescue StandardError => e
-          thread_errors + [e]
+          errors << e
         end
-        return ordered_parts(completed) if errors.empty?
+        return ordered_parts(completed_parts) if errors.empty?
 
         abort_upload(upload_id, options, errors)
       end
@@ -128,37 +128,34 @@ module Aws
         end
       end
 
-      def upload_in_threads(read_pipe, completed, options, thread_errors)
-        mutex = Mutex.new
+      def upload_with_executor(read_pipe, completed, errors, options)
+        completion_queue = Queue.new
+        queued_parts = 0
         part_number = 0
-        options.fetch(:thread_count, @thread_count).times.map do
-          thread = Thread.new do
-            loop do
-              body, thread_part_number = mutex.synchronize do
-                [read_to_part_body(read_pipe), part_number += 1]
-              end
-              break unless body || thread_part_number == 1
-
-              begin
-                part = options.merge(body: body, part_number: thread_part_number)
-                resp = @client.upload_part(part)
-                completed_part = create_completed_part(resp, part)
-                completed.push(completed_part)
-              ensure
-                clear_body(body)
-              end
-            end
-            nil
+        mutex = Mutex.new
+        loop do
+          part_body, current_part_num = mutex.synchronize do
+            [read_to_part_body(read_pipe), part_number += 1]
+          end
+          break unless part_body || current_part_num == 1
+
+          queued_parts += 1
+          @executor.post(part_body, current_part_num, options) do |body, num, opts|
+            part = opts.merge(body: body, part_number: num)
+            resp = @client.upload_part(part)
+            completed_part = create_completed_part(resp, part)
+            completed.push(completed_part)
           rescue StandardError => e
-            # keep other threads from uploading other parts
             mutex.synchronize do
-              thread_errors.push(e)
+              errors.push(e)
               read_pipe.close_read unless read_pipe.closed?
             end
-            e
+          ensure
+            clear_body(body)
+            completion_queue << :done
           end
-          thread
         end
+        queued_parts.times { completion_queue.pop }
       end
 
       def create_completed_part(resp, part)

data/lib/aws-sdk-s3/object.rb

@@ -136,10 +136,10 @@ module Aws::S3
     end
 
     # The Base64 encoded, 32-bit `CRC32 checksum` of the object. This
-    # checksum is only be present if the checksum was uploaded with the
-    # object. When you use an API operation on an object that was uploaded
-    # using multipart uploads, this value may not be a direct checksum value
-    # of the full object. Instead, it's a calculation based on the checksum
+    # checksum is only present if the checksum was uploaded with the object.
+    # When you use an API operation on an object that was uploaded using
+    # multipart uploads, this value may not be a direct checksum value of
+    # the full object. Instead, it's a calculation based on the checksum
     # values of each individual part. For more information about how
     # checksums are calculated with multipart uploads, see [ Checking object
     # integrity][1] in the *Amazon S3 User Guide*.
@@ -181,8 +181,8 @@ module Aws::S3
       data[:checksum_crc64nvme]
     end
 
-    # The Base64 encoded, 160-bit `SHA1` digest of the object. This will
-    # only be present if the object was uploaded with the object. When you
+    # The Base64 encoded, 160-bit `SHA1` digest of the object. This checksum
+    # is only present if the checksum was uploaded with the object. When you
     # use the API operation on an object that was uploaded using multipart
     # uploads, this value may not be a direct checksum value of the full
     # object. Instead, it's a calculation based on the checksum values of
@@ -198,14 +198,14 @@ module Aws::S3
       data[:checksum_sha1]
     end
 
-    # The Base64 encoded, 256-bit `SHA256` digest of the object. This will
-    # only be present if the object was uploaded with the object. When you
-    # use an API operation on an object that was uploaded using multipart
-    # uploads, this value may not be a direct checksum value of the full
-    # object. Instead, it's a calculation based on the checksum values of
-    # each individual part. For more information about how checksums are
-    # calculated with multipart uploads, see [ Checking object integrity][1]
-    # in the *Amazon S3 User Guide*.
+    # The Base64 encoded, 256-bit `SHA256` digest of the object. This
+    # checksum is only present if the checksum was uploaded with the object.
+    # When you use an API operation on an object that was uploaded using
+    # multipart uploads, this value may not be a direct checksum value of
+    # the full object. Instead, it's a calculation based on the checksum
+    # values of each individual part. For more information about how
+    # checksums are calculated with multipart uploads, see [ Checking object
+    # integrity][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -757,6 +757,8 @@ module Aws::S3
     #     grant_read: "GrantRead",
     #     grant_read_acp: "GrantReadACP",
     #     grant_write_acp: "GrantWriteACP",
+    #     if_match: "IfMatch",
+    #     if_none_match: "IfNoneMatch",
     #     metadata: {
     #       "MetadataKey" => "MetadataValue",
     #     },
@@ -1013,6 +1015,35 @@ module Aws::S3
     #   * This functionality is not supported for Amazon S3 on Outposts.
     #
     #    </note>
+    # @option options [String] :if_match
+    #   Copies the object if the entity tag (ETag) of the destination object
+    #   matches the specified tag. If the ETag values do not match, the
+    #   operation returns a `412 Precondition Failed` error. If a concurrent
+    #   operation occurs during the upload S3 returns a `409
+    #   ConditionalRequestConflict` response. On a 409 failure you should
+    #   fetch the object's ETag and retry the upload.
+    #
+    #   Expects the ETag value as a string.
+    #
+    #   For more information about conditional requests, see [RFC 7232][1].
+    #
+    #
+    #
+    #   [1]: https://tools.ietf.org/html/rfc7232
+    # @option options [String] :if_none_match
+    #   Copies the object only if the object key name at the destination does
+    #   not already exist in the bucket specified. Otherwise, Amazon S3
+    #   returns a `412 Precondition Failed` error. If a concurrent operation
+    #   occurs during the upload S3 returns a `409 ConditionalRequestConflict`
+    #   response. On a 409 failure you should retry the upload.
+    #
+    #   Expects the '*' (asterisk) character.
+    #
+    #   For more information about conditional requests, see [RFC 7232][1].
+    #
+    #
+    #
+    #   [1]: https://tools.ietf.org/html/rfc7232
     # @option options [Hash<String,String>] :metadata
     #   A map of metadata to store with the object in S3.
     # @option options [String] :metadata_directive
@@ -1535,17 +1566,15 @@ module Aws::S3
     #   you provide does not match the actual owner of the bucket, the request
     #   fails with the HTTP status code `403 Forbidden` (access denied).
     # @option options [String] :if_match
-    #   The `If-Match` header field makes the request method conditional on
-    #   ETags. If the ETag value does not match, the operation returns a `412
-    #   Precondition Failed` error. If the ETag matches or if the object
-    #   doesn't exist, the operation will return a `204 Success (No Content)
-    #   response`.
-    #
-    #   For more information about conditional requests, see [RFC 7232][1].
+    #   Deletes the object if the ETag (entity tag) value provided during the
+    #   delete operation matches the ETag of the object in S3. If the ETag
+    #   values do not match, the operation returns a `412 Precondition Failed`
+    #   error.
     #
-    #   <note markdown="1"> This functionality is only supported for directory buckets.
+    #   Expects the ETag value as a string. `If-Match` does accept a string
+    #   value of an '*' (asterisk) character to denote a match of any ETag.
     #
-    #    </note>
+    #   For more information about conditional requests, see [RFC 7232][1].
     #
     #
     #

data/lib/aws-sdk-s3/object_summary.rb

@@ -354,6 +354,8 @@ module Aws::S3
     #     grant_read: "GrantRead",
     #     grant_read_acp: "GrantReadACP",
     #     grant_write_acp: "GrantWriteACP",
+    #     if_match: "IfMatch",
+    #     if_none_match: "IfNoneMatch",
     #     metadata: {
     #       "MetadataKey" => "MetadataValue",
     #     },
@@ -610,6 +612,35 @@ module Aws::S3
     #   * This functionality is not supported for Amazon S3 on Outposts.
     #
     #    </note>
+    # @option options [String] :if_match
+    #   Copies the object if the entity tag (ETag) of the destination object
+    #   matches the specified tag. If the ETag values do not match, the
+    #   operation returns a `412 Precondition Failed` error. If a concurrent
+    #   operation occurs during the upload S3 returns a `409
+    #   ConditionalRequestConflict` response. On a 409 failure you should
+    #   fetch the object's ETag and retry the upload.
+    #
+    #   Expects the ETag value as a string.
+    #
+    #   For more information about conditional requests, see [RFC 7232][1].
+    #
+    #
+    #
+    #   [1]: https://tools.ietf.org/html/rfc7232
+    # @option options [String] :if_none_match
+    #   Copies the object only if the object key name at the destination does
+    #   not already exist in the bucket specified. Otherwise, Amazon S3
+    #   returns a `412 Precondition Failed` error. If a concurrent operation
+    #   occurs during the upload S3 returns a `409 ConditionalRequestConflict`
+    #   response. On a 409 failure you should retry the upload.
+    #
+    #   Expects the '*' (asterisk) character.
+    #
+    #   For more information about conditional requests, see [RFC 7232][1].
+    #
+    #
+    #
+    #   [1]: https://tools.ietf.org/html/rfc7232
     # @option options [Hash<String,String>] :metadata
     #   A map of metadata to store with the object in S3.
     # @option options [String] :metadata_directive
@@ -1132,17 +1163,15 @@ module Aws::S3
     #   you provide does not match the actual owner of the bucket, the request
     #   fails with the HTTP status code `403 Forbidden` (access denied).
     # @option options [String] :if_match
-    #   The `If-Match` header field makes the request method conditional on
-    #   ETags. If the ETag value does not match, the operation returns a `412
-    #   Precondition Failed` error. If the ETag matches or if the object
-    #   doesn't exist, the operation will return a `204 Success (No Content)
-    #   response`.
+    #   Deletes the object if the ETag (entity tag) value provided during the
+    #   delete operation matches the ETag of the object in S3. If the ETag
+    #   values do not match, the operation returns a `412 Precondition Failed`
+    #   error.
     #
-    #   For more information about conditional requests, see [RFC 7232][1].
+    #   Expects the ETag value as a string. `If-Match` does accept a string
+    #   value of an '*' (asterisk) character to denote a match of any ETag.
     #
-    #   <note markdown="1"> This functionality is only supported for directory buckets.
-    #
-    #    </note>
+    #   For more information about conditional requests, see [RFC 7232][1].
     #
     #
     #

data/lib/aws-sdk-s3/object_version.rb

@@ -312,17 +312,15 @@ module Aws::S3
     #   you provide does not match the actual owner of the bucket, the request
     #   fails with the HTTP status code `403 Forbidden` (access denied).
     # @option options [String] :if_match
-    #   The `If-Match` header field makes the request method conditional on
-    #   ETags. If the ETag value does not match, the operation returns a `412
-    #   Precondition Failed` error. If the ETag matches or if the object
-    #   doesn't exist, the operation will return a `204 Success (No Content)
-    #   response`.
-    #
-    #   For more information about conditional requests, see [RFC 7232][1].
+    #   Deletes the object if the ETag (entity tag) value provided during the
+    #   delete operation matches the ETag of the object in S3. If the ETag
+    #   values do not match, the operation returns a `412 Precondition Failed`
+    #   error.
     #
-    #   <note markdown="1"> This functionality is only supported for directory buckets.
+    #   Expects the ETag value as a string. `If-Match` does accept a string
+    #   value of an '*' (asterisk) character to denote a match of any ETag.
     #
-    #    </note>
+    #   For more information about conditional requests, see [RFC 7232][1].
     #
     #
     #

data/lib/aws-sdk-s3/plugins/endpoints.rb

@@ -25,7 +25,7 @@ The endpoint provider used to resolve endpoints. Any object that responds to
 
       option(
         :disable_s3_express_session_auth,
-        doc_type: 'Boolean',
+        doc_type: 'boolean',
         docstring: <<~DOCS) do |cfg|
 Parameter to indicate whether S3Express session auth should be disabled
         DOCS

data/lib/aws-sdk-s3/transfer_manager.rb

@@ -2,27 +2,74 @@
 
 module Aws
   module S3
-    # A high-level S3 transfer utility that provides enhanced upload and download
-    # capabilities with automatic multipart handling, progress tracking, and
-    # handling of large files. The following features are supported:
+    # A high-level S3 transfer utility that provides enhanced upload and download capabilities with automatic
+    # multipart handling, progress tracking, and handling of large files. The following features are supported:
     #
     # * upload a file with multipart upload
     # * upload a stream with multipart upload
     # * download a S3 object with multipart download
     # * track transfer progress by using progress listener
     #
+    # ## Executor Management
+    # TransferManager uses executors to handle concurrent operations during multipart transfers. You can control
+    # concurrency behavior by providing a custom executor or relying on the default executor management.
+    #
+    # ### Default Behavior
+    # When no `:executor` is provided, TransferManager creates a new DefaultExecutor for each individual
+    # operation (`download_file`, `upload_file`, etc.) and automatically shuts it down when that operation completes.
+    # Each operation gets its own isolated thread pool with the specified `:thread_count` (default 10 threads).
+    #
+    # ### Custom Executor
+    # You can provide your own executor (e.g., `Concurrent::ThreadPoolExecutor`) for fine-grained control over thread
+    # pools and resource management. When using a custom executor, you are responsible for shutting it down
+    # when finished. The executor may be reused across multiple TransferManager operations.
+    #
+    # Custom executors must implement the same interface as DefaultExecutor.
+    #
+    # **Required methods:**
+    #
+    #   * `post(*args, &block)` - Execute a task with given arguments and block
+    #   * `kill` - Immediately terminate all running tasks
+    #
+    # **Optional methods:**
+    #
+    #   * `shutdown(timeout = nil)` - Gracefully shutdown the executor with optional timeout
+    #
+    # @example Using default executor (automatic creation and shutdown)
+    #     tm = TransferManager.new # No executor provided
+    #     # DefaultExecutor created, used, and shutdown automatically
+    #     tm.download_file('/path/to/file', bucket: 'bucket', key: 'key')
+    #
+    # @example Using custom executor (manual shutdown required)
+    #     require 'concurrent-ruby'
+    #
+    #     executor = Concurrent::ThreadPoolExecutor.new(max_threads: 5)
+    #     tm = TransferManager.new(executor: executor)
+    #     tm.download_file('/path/to/file1', bucket: 'bucket', key: 'key1')
+    #     executor.shutdown # You must shutdown custom executors
+    #
     class TransferManager
+
       # @param [Hash] options
       # @option options [S3::Client] :client (S3::Client.new)
       #   The S3 client to use for {TransferManager} operations. If not provided, a new default client
       #   will be created automatically.
+      # @option options [Object] :executor
+      #   The executor to use for multipart operations. Must implement the same interface as {DefaultExecutor}.
+      #   If not provided, a new {DefaultExecutor} will be created automatically for each operation and
+      #   shutdown after completion. When provided a custom executor, it will be reused across operations, and
+      #   you are responsible for shutting it down when finished.
       def initialize(options = {})
-        @client = options.delete(:client) || Client.new
+        @client = options[:client] || Client.new
+        @executor = options[:executor]
       end
 
       # @return [S3::Client]
       attr_reader :client
 
+      # @return [Object]
+      attr_reader :executor
+
       # Downloads a file in S3 to a path on disk.
       #
       #     # small files (< 5MB) are downloaded in a single API call
@@ -48,7 +95,13 @@ module Aws
       # @param [String, Pathname, File, Tempfile] destination
       #   Where to download the file to. This can either be a String or Pathname to the file, an open File object,
       #   or an open Tempfile object. If you pass an open File or Tempfile object, then you are responsible for
-      #   closing it after the download completes.
+      #   closing it after the download completes. Download behavior varies by destination type:
+      #
+      #   * **String/Pathname paths**: Downloads to a temporary file first, then atomically moves to the final
+      #    destination. This prevents corruption of any existing file if the download fails.
+      #   * **File/Tempfile objects**: Downloads directly to the file object without using temporary files.
+      #    You are responsible for managing the file object's state and closing it after the download completes.
+      #    If the download fails, the file object may contain partial data.
       #
       # @param [String] bucket
       #   The name of the S3 bucket to upload to.
@@ -68,10 +121,7 @@ module Aws
       # @option options [Integer] :chunk_size required in `"get_range"` mode.
       #
       # @option options [Integer] :thread_count (10) Customize threads used in the multipart download.
-      #
-      # @option options [String] :version_id The object version id used to retrieve the object.
-      #
-      #     @see https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html ObjectVersioning
+      #   Only used when no custom executor is provided (creates {DefaultExecutor} with given thread count).
       #
       # @option options [String] :checksum_mode ("ENABLED")
       #   When `"ENABLED"` and the object has a stored checksum, it will be used to validate the download and will
@@ -96,8 +146,11 @@ module Aws
       # @see Client#get_object
       # @see Client#head_object
       def download_file(destination, bucket:, key:, **options)
-        downloader = FileDownloader.new(client: @client)
-        downloader.download(destination, options.merge(bucket: bucket, key: key))
+        download_opts = options.merge(bucket: bucket, key: key)
+        executor = @executor || DefaultExecutor.new(max_threads: download_opts.delete(:thread_count))
+        downloader = FileDownloader.new(client: @client, executor: executor)
+        downloader.download(destination, download_opts)
+        executor.shutdown unless @executor
         true
       end
 
@@ -133,7 +186,7 @@ module Aws
       #   A file on the local file system that will be uploaded. This can either be a `String` or `Pathname` to the
       #   file, an open `File` object, or an open `Tempfile` object. If you pass an open `File` or `Tempfile` object,
       #   then you are responsible for closing it after the upload completes. When using an open Tempfile, rewind it
-      #   before  uploading or else the object will be empty.
+      #   before uploading or else the object will be empty.
       #
       # @param [String] bucket
       #   The name of the S3 bucket to upload to.
@@ -150,15 +203,14 @@ module Aws
       #   Files larger han or equal to `:multipart_threshold` are uploaded using the S3 multipart upload APIs.
       #   Default threshold is `100MB`.
       #
-      # @option options [Integer] :thread_count (10)
-      #    The number of parallel multipart uploads. This option is not used if the file is smaller than
-      #    `:multipart_threshold`.
+      # @option options [Integer] :thread_count (10) Customize threads used in the multipart upload.
+      #   Only used when no custom executor is provided (creates {DefaultExecutor} with the given thread count).
       #
       # @option options [Proc] :progress_callback (nil)
       #   A Proc that will be called when each chunk of the upload is sent.
       #   It will be invoked with `[bytes_read]` and  `[total_sizes]`.
       #
-      # @raise [MultipartUploadError] If an file is being uploaded in parts, and the upload can not be completed,
+      # @raise [MultipartUploadError] If a file is being uploaded in parts, and the upload can not be completed,
       #   then the upload is aborted and this error is raised.  The raised error has a `#errors` method that
       #   returns the failures that caused the upload to be aborted.
       #
@@ -169,13 +221,16 @@ module Aws
       # @see Client#complete_multipart_upload
       # @see Client#upload_part
       def upload_file(source, bucket:, key:, **options)
-        uploading_options = options.dup
+        upload_opts = options.merge(bucket: bucket, key: key)
+        executor = @executor || DefaultExecutor.new(max_threads: upload_opts.delete(:thread_count))
         uploader = FileUploader.new(
-          multipart_threshold: uploading_options.delete(:multipart_threshold),
-          client: @client
+          multipart_threshold: upload_opts.delete(:multipart_threshold),
+          client: @client,
+          executor: executor
         )
-        response = uploader.upload(source, uploading_options.merge(bucket: bucket, key: key))
+        response = uploader.upload(source, upload_opts)
         yield response if block_given?
+        executor.shutdown unless @executor
         true
       end
 
@@ -211,7 +266,8 @@ module Aws
       #   {Client#upload_part} can be provided.
       #
       # @option options [Integer] :thread_count (10)
-      #   The number of parallel multipart uploads.
+      #   The number of parallel multipart uploads. Only used when no custom executor is provided (creates
+      #   {DefaultExecutor} with the given thread count). An additional thread is used internally for task coordination.
       #
       # @option options [Boolean] :tempfile (false)
       #   Normally read data is stored in memory when building the parts in order to complete the underlying
@@ -231,14 +287,16 @@ module Aws
       # @see Client#complete_multipart_upload
       # @see Client#upload_part
       def upload_stream(bucket:, key:, **options, &block)
-        uploading_options = options.dup
+        upload_opts = options.merge(bucket: bucket, key: key)
+        executor = @executor || DefaultExecutor.new(max_threads: upload_opts.delete(:thread_count))
         uploader = MultipartStreamUploader.new(
           client: @client,
-          thread_count: uploading_options.delete(:thread_count),
-          tempfile: uploading_options.delete(:tempfile),
-          part_size: uploading_options.delete(:part_size)
+          executor: executor,
+          tempfile: upload_opts.delete(:tempfile),
+          part_size: upload_opts.delete(:part_size)
         )
-        uploader.upload(uploading_options.merge(bucket: bucket, key: key), &block)
+        uploader.upload(upload_opts, &block)
+        executor.shutdown unless @executor
         true
       end
     end