aws-sdk-s3 1.196.1 → 1.197.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72291dc4a45c81045393df33c2dc26b215e8b67d50f33e097d7685da2a02ca47
-  data.tar.gz: eeb0aacd605389c7511cb63684362c12351c68648fa32f7d888e00ea7b0a7d9d
+  metadata.gz: 206194d0b6217c7fd01477cc0407b4d55080bdd269f14d33f3ae072fabfaa2ee
+  data.tar.gz: e269ddd5c94adc905a49ddf2f8fa80f1446684889d934aefd14d38136f81822b
 SHA512:
-  metadata.gz: 20dcb199634a44435dee8acb5d775dc9ed7d50b60c10091425416b692783e5de48ae91df2a4525c0543391584e08338a37c8c9b43dfebe60ffb609a99c535910
-  data.tar.gz: 2c4fbba3c97ae00405a8a2ea973145194126f027cf070229a3d80cc47900b2d8e3a1106f69f510ef4c765f090e3d56806f9b5a470449caa3ca898527377b9601
+  metadata.gz: 2d27932019687706da5456a0c7dfa3e4c9bb81e3173105f6572e7a1afd4af96e553e94fedb19ca3c0052fcc4f3b297fcb14fe3719da037d9a9b333701fc35c24
+  data.tar.gz: bc7d64a072edfe9fc2154fec0834e6d27b19f2fbdca79b39571b1057cd73e5041abb113678d5c03414e664bd9422a8a714c37ec84015865de6566dc5b1a5909c

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 Unreleased Changes
 ------------------
 
+1.197.0 (2025-08-19)
+------------------
+
+* Issue - When multipart stream uploader fails to complete multipart upload, it calls abort multipart upload.
+
+* Issue - For `Aws::S3::Object` class, the following methods have been deprecated: `download_file`, `upload_file` and `upload_stream`. Use `Aws::S3::TransferManager` instead.
+
+* Feature - Add `Aws::S3::TransferManager`, a S3 transfer utility that provides upload/download capabilities with automatic multipart handling, progress tracking, and handling of large files. 
+
 1.196.1 (2025-08-05)
 ------------------
 

data/VERSION

@@ -1 +1 @@
-1.196.1
+1.197.0

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

@@ -21735,7 +21735,7 @@ module Aws::S3
         tracer: tracer
       )
       context[:gem_name] = 'aws-sdk-s3'
-      context[:gem_version] = '1.196.1'
+      context[:gem_version] = '1.197.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

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

@@ -398,6 +398,7 @@ module Aws
         end
         true
       end
+      deprecated(:upload_stream, use: 'Aws::S3::TransferManager#upload_stream', version: 'next major version')
 
       # Uploads a file from disk to the current object in S3.
       #
@@ -465,6 +466,7 @@ module Aws
         yield response if block_given?
         true
       end
+      deprecated(:upload_file, use: 'Aws::S3::TransferManager#upload_file', version: 'next major version')
 
       # Downloads a file in S3 to a path on disk.
       #
@@ -534,6 +536,7 @@ module Aws
         end
         true
       end
+      deprecated(:download_file, use: 'Aws::S3::TransferManager#download_file', version: 'next major version')
 
       class Collection < Aws::Resources::Collection
         alias_method :delete, :batch_delete!

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

@@ -18,13 +18,13 @@ module Aws
     autoload :ObjectMultipartCopier, 'aws-sdk-s3/object_multipart_copier'
     autoload :PresignedPost, 'aws-sdk-s3/presigned_post'
     autoload :Presigner, 'aws-sdk-s3/presigner'
+    autoload :TransferManager, 'aws-sdk-s3/transfer_manager'
 
     # s3 express session auth
     autoload :ExpressCredentials, 'aws-sdk-s3/express_credentials'
     autoload :ExpressCredentialsProvider, 'aws-sdk-s3/express_credentials_provider'
 
     # s3 access grants auth
-
     autoload :AccessGrantsCredentials, 'aws-sdk-s3/access_grants_credentials'
     autoload :AccessGrantsCredentialsProvider, 'aws-sdk-s3/access_grants_credentials_provider'
   end

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

@@ -7,7 +7,7 @@ module Aws
     # @api private
     class FileUploader
 
-      ONE_HUNDRED_MEGABYTES = 100 * 1024 * 1024
+      DEFAULT_MULTIPART_THRESHOLD = 100 * 1024 * 1024
 
       # @param [Hash] options
       # @option options [Client] :client
@@ -15,15 +15,13 @@ module Aws
       def initialize(options = {})
         @options = options
         @client = options[:client] || Client.new
-        @multipart_threshold = options[:multipart_threshold] ||
-                               ONE_HUNDRED_MEGABYTES
+        @multipart_threshold = options[:multipart_threshold] || DEFAULT_MULTIPART_THRESHOLD
       end
 
       # @return [Client]
       attr_reader :client
 
-      # @return [Integer] Files larger than or equal to this in bytes are uploaded
-      #   using a {MultipartFileUploader}.
+      # @return [Integer] Files larger than or equal to this in bytes are uploaded using a {MultipartFileUploader}.
       attr_reader :multipart_threshold
 
       # @param [String, Pathname, File, Tempfile] source The file to upload.

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

@@ -9,17 +9,11 @@ module Aws
     class MultipartFileUploader
 
       MIN_PART_SIZE = 5 * 1024 * 1024 # 5MB
-
       MAX_PARTS = 10_000
-
-      THREAD_COUNT = 10
-
+      DEFAULT_THREAD_COUNT = 10
       CREATE_OPTIONS = Set.new(Client.api.operation(:create_multipart_upload).input.shape.member_names)
-
       COMPLETE_OPTIONS = Set.new(Client.api.operation(:complete_multipart_upload).input.shape.member_names)
-
       UPLOAD_PART_OPTIONS = Set.new(Client.api.operation(:upload_part).input.shape.member_names)
-
       CHECKSUM_KEYS = Set.new(
         Client.api.operation(:upload_part).input.shape.members.map do |n, s|
           n if s.location == 'header' && s.location_name.start_with?('x-amz-checksum-')
@@ -27,10 +21,10 @@ module Aws
       )
 
       # @option options [Client] :client
-      # @option options [Integer] :thread_count (THREAD_COUNT)
+      # @option options [Integer] :thread_count (DEFAULT_THREAD_COUNT)
       def initialize(options = {})
         @client = options[:client] || Client.new
-        @thread_count = options[:thread_count] || THREAD_COUNT
+        @thread_count = options[:thread_count] || DEFAULT_THREAD_COUNT
       end
 
       # @return [Client]

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

@@ -9,33 +9,19 @@ module Aws
   module S3
     # @api private
     class MultipartStreamUploader
-      # api private
-      PART_SIZE = 5 * 1024 * 1024 # 5MB
 
-      # api private
-      THREAD_COUNT = 10
-
-      # api private
-      TEMPFILE_PREIX = 'aws-sdk-s3-upload_stream'.freeze
-
-      # @api private
-      CREATE_OPTIONS =
-        Set.new(Client.api.operation(:create_multipart_upload).input.shape.member_names)
-
-      # @api private
-      UPLOAD_PART_OPTIONS =
-        Set.new(Client.api.operation(:upload_part).input.shape.member_names)
-
-      # @api private
-      COMPLETE_UPLOAD_OPTIONS =
-        Set.new(Client.api.operation(:complete_multipart_upload).input.shape.member_names)
+      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)
 
       # @option options [Client] :client
       def initialize(options = {})
         @client = options[:client] || Client.new
         @tempfile = options[:tempfile]
-        @part_size = options[:part_size] || PART_SIZE
-        @thread_count = options[:thread_count] || THREAD_COUNT
+        @part_size = options[:part_size] || DEFAULT_PART_SIZE
+        @thread_count = options[:thread_count] || DEFAULT_THREAD_COUNT
       end
 
       # @return [Client]
@@ -43,7 +29,7 @@ module Aws
 
       # @option options [required,String] :bucket
       # @option options [required,String] :key
-      # @option options [Integer] :thread_count (THREAD_COUNT)
+      # @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
@@ -61,11 +47,10 @@ module Aws
 
       def complete_upload(upload_id, parts, options)
         @client.complete_multipart_upload(
-          **complete_opts(options).merge(
-            upload_id: upload_id,
-            multipart_upload: { parts: parts }
-          )
+          **complete_opts(options).merge(upload_id: upload_id, multipart_upload: { parts: parts })
         )
+      rescue StandardError => e
+        abort_upload(upload_id, options, [e])
       end
 
       def upload_parts(upload_id, options, &block)
@@ -74,9 +59,11 @@ module Aws
         errors = begin
           IO.pipe do |read_pipe, write_pipe|
             threads = upload_in_threads(
-              read_pipe, completed,
+              read_pipe,
+              completed,
               upload_part_opts(options).merge(upload_id: upload_id),
-              thread_errors)
+              thread_errors
+            )
             begin
               block.call(write_pipe)
             ensure
@@ -85,62 +72,53 @@ module Aws
             end
             threads.map(&:value).compact
           end
-        rescue => e
+        rescue StandardError => e
           thread_errors + [e]
         end
+        return ordered_parts(completed) if errors.empty?
 
-        if errors.empty?
-          Array.new(completed.size) { completed.pop }.sort_by { |part| part[:part_number] }
-        else
-          abort_upload(upload_id, options, errors)
-        end
+        abort_upload(upload_id, options, errors)
       end
 
       def abort_upload(upload_id, options, errors)
-        @client.abort_multipart_upload(
-          bucket: options[:bucket],
-          key: options[:key],
-          upload_id: upload_id
-        )
+        @client.abort_multipart_upload(bucket: options[:bucket], key: options[:key], upload_id: upload_id)
         msg = "multipart upload failed: #{errors.map(&:message).join('; ')}"
         raise MultipartUploadError.new(msg, errors)
-      rescue MultipartUploadError => error
-        raise error
-      rescue => error
-        msg = "failed to abort multipart upload: #{error.message}. "\
+      rescue MultipartUploadError => e
+        raise e
+      rescue StandardError => e
+        msg = "failed to abort multipart upload: #{e.message}. "\
           "Multipart upload failed: #{errors.map(&:message).join('; ')}"
-        raise MultipartUploadError.new(msg, errors + [error])
+        raise MultipartUploadError.new(msg, errors + [e])
       end
 
       def create_opts(options)
-        CREATE_OPTIONS.inject({}) do |hash, key|
+        CREATE_OPTIONS.each_with_object({}) do |key, hash|
           hash[key] = options[key] if options.key?(key)
-          hash
         end
       end
 
       def upload_part_opts(options)
-        UPLOAD_PART_OPTIONS.inject({}) do |hash, key|
+        UPLOAD_PART_OPTIONS.each_with_object({}) do |key, hash|
           hash[key] = options[key] if options.key?(key)
-          hash
         end
       end
 
       def complete_opts(options)
-        COMPLETE_UPLOAD_OPTIONS.inject({}) do |hash, key|
+        COMPLETE_UPLOAD_OPTIONS.each_with_object({}) do |key, hash|
           hash[key] = options[key] if options.key?(key)
-          hash
         end
       end
 
       def read_to_part_body(read_pipe)
         return if read_pipe.closed?
-        temp_io = @tempfile ? Tempfile.new(TEMPFILE_PREIX) : StringIO.new(String.new)
+
+        temp_io = @tempfile ? Tempfile.new('aws-sdk-s3-upload_stream') : StringIO.new(String.new)
         temp_io.binmode
         bytes_copied = IO.copy_stream(read_pipe, temp_io, @part_size)
         temp_io.rewind
-        if bytes_copied == 0
-          if Tempfile === temp_io
+        if bytes_copied.zero?
+          if temp_io.is_a?(Tempfile)
             temp_io.close
             temp_io.unlink
           end
@@ -155,48 +133,62 @@ module Aws
         part_number = 0
         options.fetch(:thread_count, @thread_count).times.map do
           thread = Thread.new do
-            begin
-              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 = {etag: resp.etag, part_number: part[:part_number]}
-
-                  # get the requested checksum from the response
-                  if part[:checksum_algorithm]
-                    k = "checksum_#{part[:checksum_algorithm].downcase}".to_sym
-                    completed_part[k] = resp[k]
-                  end
-                  completed.push(completed_part)
-                ensure
-                  if Tempfile === body
-                    body.close
-                    body.unlink
-                  elsif StringIO === body
-                    body.string.clear
-                  end
-                end
+            loop do
+              body, thread_part_number = mutex.synchronize do
+                [read_to_part_body(read_pipe), part_number += 1]
               end
-              nil
-            rescue => error
-              # keep other threads from uploading other parts
-              mutex.synchronize do
-                thread_errors.push(error)
-                read_pipe.close_read unless read_pipe.closed?
+              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
-              error
             end
+            nil
+          rescue StandardError => e
+            # keep other threads from uploading other parts
+            mutex.synchronize do
+              thread_errors.push(e)
+              read_pipe.close_read unless read_pipe.closed?
+            end
+            e
           end
           thread
         end
       end
+
+      def create_completed_part(resp, part)
+        completed_part = { etag: resp.etag, part_number: part[:part_number] }
+        return completed_part unless part[:checksum_algorithm]
+
+        # get the requested checksum from the response
+        k = "checksum_#{part[:checksum_algorithm].downcase}".to_sym
+        completed_part[k] = resp[k]
+        completed_part
+      end
+
+      def ordered_parts(parts)
+        sorted = []
+        until parts.empty?
+          part = parts.pop
+          index = sorted.bsearch_index { |p| p[:part_number] >= part[:part_number] } || sorted.size
+          sorted.insert(index, part)
+        end
+        sorted
+      end
+
+      def clear_body(body)
+        if body.is_a?(Tempfile)
+          body.close
+          body.unlink
+        elsif body.is_a?(StringIO)
+          body.string.clear
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+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:
+    #
+    # * 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
+    #
+    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.
+      def initialize(options = {})
+        @client = options.delete(:client) || Client.new
+      end
+
+      # @return [S3::Client]
+      attr_reader :client
+
+      # Downloads a file in S3 to a path on disk.
+      #
+      #     # small files (< 5MB) are downloaded in a single API call
+      #     tm = TransferManager.new
+      #     tm.download_file('/path/to/file', bucket: 'bucket', key: 'key')
+      #
+      # Files larger than 5MB are downloaded using multipart method:
+      #
+      #     # large files are split into parts and the parts are downloaded in parallel
+      #     tm.download_file('/path/to/large_file', bucket: 'bucket', key: 'key')
+      #
+      # You can provide a callback to monitor progress of the download:
+      #
+      #     # bytes and part_sizes are each an array with 1 entry per part
+      #     # part_sizes may not be known until the first bytes are retrieved
+      #     progress = proc do |bytes, part_sizes, file_size|
+      #       bytes.map.with_index do |b, i|
+      #         puts "Part #{i + 1}: #{b} / #{part_sizes[i]}".join(' ') + "Total: #{100.0 * bytes.sum / file_size}%"
+      #       end
+      #     end
+      #     tm.download_file('/path/to/file', bucket: 'bucket', key: 'key', progress_callback: progress)
+      #
+      # @param [String] destination
+      #   Where to download the file to.
+      #
+      # @param [String] bucket
+      #   The name of the S3 bucket to upload to.
+      #
+      # @param [String] key
+      #   The object key name in S3 bucket.
+      #
+      # @param [Hash] options
+      #   Additional options for {Client#get_object} and #{Client#head_object} may be provided.
+      #
+      # @option options [String] :mode ("auto") `"auto"`, `"single_request"` or `"get_range"`
+      #
+      #  * `"auto"` mode is enabled by default, which performs `multipart_download`
+      #  * `"single_request`" mode forces only 1 GET request is made in download
+      #  * `"get_range"` mode requires `:chunk_size` parameter to configured in customizing each range size
+      #
+      # @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
+      #
+      # @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
+      #   raise an `Aws::Errors::ChecksumError` if checksum validation fails. You may provide a `on_checksum_validated`
+      #   callback if you need to verify that validation occurred and which algorithm was used.
+      #   To disable checksum validation, set `checksum_mode` to `"DISABLED"`.
+      #
+      # @option options [Callable] :on_checksum_validated
+      #   Called each time a request's checksum is validated with the checksum algorithm and the
+      #   response.  For multipart downloads, this will be called for each part that is downloaded and validated.
+      #
+      # @option options [Proc] :progress_callback
+      #   A Proc that will be called when each chunk of the download is received. It will be invoked with
+      #   `bytes_read`, `part_sizes`, `file_size`. When the object is downloaded as parts (rather than by ranges),
+      #   the `part_sizes` will not be known ahead of time and will be `nil` in the callback until the first bytes
+      #   in the part are received.
+      #
+      # @raise [MultipartDownloadError] Raised when an object validation fails outside of service errors.
+      #
+      # @return [Boolean] Returns `true` when the file is downloaded without any errors.
+      #
+      # @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))
+        true
+      end
+
+      # Uploads a file from disk to S3.
+      #
+      #     # a small file are uploaded with PutObject API
+      #     tm = TransferManager.new
+      #     tm.upload_file('/path/to/small_file', bucket: 'bucket', key: 'key')
+      #
+      # Files larger than or equal to `:multipart_threshold` are uploaded using multipart upload APIs.
+      #
+      #     # large files are automatically split into parts and the parts are uploaded in parallel
+      #     tm.upload_file('/path/to/large_file', bucket: 'bucket', key: 'key')
+      #
+      # The response of the S3 upload API is yielded if a block given.
+      #
+      #     # API response will have etag value of the file
+      #     tm.upload_file('/path/to/file', bucket: 'bucket', key: 'key') do |response|
+      #       etag = response.etag
+      #     end
+      #
+      # You can provide a callback to monitor progress of the upload:
+      #
+      #     # bytes and totals are each an array with 1 entry per part
+      #     progress = proc do |bytes, totals|
+      #       bytes.map.with_index do |b, i|
+      #           puts "Part #{i + 1}: #{b} / #{totals[i]} " + "Total: #{100.0 * bytes.sum / totals.sum}%"
+      #       end
+      #     end
+      #     tm.upload_file('/path/to/file', bucket: 'bucket', key: 'key', progress_callback: progress)
+      #
+      # @param [String, Pathname, File, Tempfile] source
+      #   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.
+      #
+      # @param [String] bucket
+      #   The name of the S3 bucket to upload to.
+      #
+      # @param [String] key
+      #   The object key name for the uploaded file.
+      #
+      # @param [Hash] options
+      #   Additional options for {Client#put_object} when file sizes below the multipart threshold.
+      #   For files larger than the multipart threshold, options for {Client#create_multipart_upload},
+      #   {Client#complete_multipart_upload}, and {Client#upload_part} can be provided.
+      #
+      # @option options [Integer] :multipart_threshold (104857600)
+      #   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 [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,
+      #   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.
+      #
+      # @return [Boolean] Returns `true` when the file is uploaded without any errors.
+      #
+      # @see Client#put_object
+      # @see Client#create_multipart_upload
+      # @see Client#complete_multipart_upload
+      # @see Client#upload_part
+      def upload_file(source, bucket:, key:, **options)
+        uploading_options = options.dup
+        uploader = FileUploader.new(
+          multipart_threshold: uploading_options.delete(:multipart_threshold),
+          client: @client
+        )
+        response = uploader.upload(source, uploading_options.merge(bucket: bucket, key: key))
+        yield response if block_given?
+        true
+      end
+
+      # Uploads a stream in a streaming fashion to S3.
+      #
+      # Passed chunks automatically split into multipart upload parts and the parts are uploaded in parallel.
+      # This allows for streaming uploads that never touch the disk.
+      #
+      # **Note**: There are known issues in JRuby until jruby-9.1.15.0, so avoid using this with older JRuby versions.
+      #
+      # @example Streaming chunks of data
+      #     tm = TransferManager.new
+      #     tm.upload_stream(bucket: 'bucket', key: 'key') do |write_stream|
+      #       10.times { write_stream << 'foo' }
+      #     end
+      # @example Streaming chunks of data
+      #     tm.upload_stream(bucket: 'bucket', key: 'key') do |write_stream|
+      #       IO.copy_stream(IO.popen('ls'), write_stream)
+      #     end
+      # @example Streaming chunks of data
+      #     tm.upload_stream(bucket: 'bucket', key: 'key') do |write_stream|
+      #       IO.copy_stream(STDIN, write_stream)
+      #     end
+      #
+      # @param [String] bucket
+      #   The name of the S3 bucket to upload to.
+      #
+      # @param [String] key
+      #   The object key name for the uploaded file.
+      #
+      # @param [Hash] options
+      #   Additional options for {Client#create_multipart_upload}, {Client#complete_multipart_upload}, and
+      #   {Client#upload_part} can be provided.
+      #
+      # @option options [Integer] :thread_count (10)
+      #   The number of parallel multipart uploads.
+      #
+      # @option options [Boolean] :tempfile (false)
+      #   Normally read data is stored in memory when building the parts in order to complete the underlying
+      #   multipart upload. By passing `:tempfile => true`, the data read will be temporarily stored on disk reducing
+      #   the memory footprint vastly.
+      #
+      # @option options [Integer] :part_size (5242880)
+      #   Define how big each part size but the last should be. Default `:part_size` is `5 * 1024 * 1024`.
+      #
+      # @raise [MultipartUploadError] If an object 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.
+      #
+      # @return [Boolean] Returns `true` when the object is uploaded without any errors.
+      #
+      # @see Client#create_multipart_upload
+      # @see Client#complete_multipart_upload
+      # @see Client#upload_part
+      def upload_stream(bucket:, key:, **options, &block)
+        uploading_options = options.dup
+        uploader = MultipartStreamUploader.new(
+          client: @client,
+          thread_count: uploading_options.delete(:thread_count),
+          tempfile: uploading_options.delete(:tempfile),
+          part_size: uploading_options.delete(:part_size)
+        )
+        uploader.upload(uploading_options.merge(bucket: bucket, key: key), &block)
+        true
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3.rb

@@ -75,7 +75,7 @@ module Aws::S3
   autoload :ObjectVersion, 'aws-sdk-s3/object_version'
   autoload :EventStreams, 'aws-sdk-s3/event_streams'
 
-  GEM_VERSION = '1.196.1'
+  GEM_VERSION = '1.197.0'
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-s3
 version: !ruby/object:Gem::Version
-  version: 1.196.1
+  version: 1.197.0
 platform: ruby
 authors:
 - Amazon Web Services
@@ -170,6 +170,7 @@ files:
 - lib/aws-sdk-s3/presigned_post.rb
 - lib/aws-sdk-s3/presigner.rb
 - lib/aws-sdk-s3/resource.rb
+- lib/aws-sdk-s3/transfer_manager.rb
 - lib/aws-sdk-s3/types.rb
 - lib/aws-sdk-s3/waiters.rb
 - sig/bucket.rbs