aws-sdk-s3 1.196.0 → 1.196.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52142f91568fe72f865055a683d9cf9f4a86c0d6446f4c7b2ab491a5b37f2cd9
-  data.tar.gz: 06e34c3d319a400fe08d08b8aed7f49813f4cb99e6129f4eee6a2b8fdbc452a9
+  metadata.gz: 72291dc4a45c81045393df33c2dc26b215e8b67d50f33e097d7685da2a02ca47
+  data.tar.gz: eeb0aacd605389c7511cb63684362c12351c68648fa32f7d888e00ea7b0a7d9d
 SHA512:
-  metadata.gz: a73af036ed37f5ed060d993d681e747ec554176bb09d5f4bbb77201b60280c23f47a69e5757cc9fb8f33f3e0bf971bb0fd065376a93f897990d053a157385a97
-  data.tar.gz: d0aac2333813cd782ec4f1d0699288fcc4ed720583883a17ae77f35ccd725b5f3471d931acc2c820928859665ee13c8c8efde428cb4e638840bdb4446bb2161c
+  metadata.gz: 20dcb199634a44435dee8acb5d775dc9ed7d50b60c10091425416b692783e5de48ae91df2a4525c0543391584e08338a37c8c9b43dfebe60ffb609a99c535910
+  data.tar.gz: 2c4fbba3c97ae00405a8a2ea973145194126f027cf070229a3d80cc47900b2d8e3a1106f69f510ef4c765f090e3d56806f9b5a470449caa3ca898527377b9601

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 Unreleased Changes
 ------------------
 
+1.196.1 (2025-08-05)
+------------------
+
+* Issue - Add range validation to multipart download to ensure all parts are successfully processed.
+
+* Issue - When multipart uploader fails to complete multipart upload, it calls abort multipart upload.
+
+* Issue - Clean up partially downloaded file on multipart `download_file` failure while preserving existing file.
+
 1.196.0 (2025-08-04)
 ------------------
 

data/VERSION

@@ -1 +1 @@
-1.196.0
+1.196.1

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.0'
+      context[:gem_version] = '1.196.1'
       Seahorse::Client::Request.new(handlers, context)
     end
 

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

@@ -404,8 +404,7 @@ module Aws
       #     # small files are uploaded in a single API call
       #     obj.upload_file('/path/to/file')
       #
-      # Files larger than or equal to `:multipart_threshold` are uploaded
-      # using the Amazon S3 multipart upload APIs.
+      # Files larger than or equal to `:multipart_threshold` are uploaded using the Amazon S3 multipart upload APIs.
       #
       #     # large files are automatically split into parts
       #     # and the parts are uploaded in parallel
@@ -421,47 +420,37 @@ module Aws
       # 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.new do |bytes, totals|
-      #       puts bytes.map.with_index { |b, i| "Part #{i+1}: #{b} / #{totals[i]}"}.join(' ') + "Total: #{100.0 * bytes.sum / totals.sum }%" }
+      #     progress = proc do |bytes, totals|
+      #       puts bytes.map.with_index { |b, i| "Part #{i+1}: #{b} / #{totals[i]}"}.join(' ') + "Total: #{100.0 * bytes.sum / totals.sum }%"
       #     end
       #     obj.upload_file('/path/to/file', progress_callback: progress)
       #
-      # @param [String, Pathname, File, Tempfile] source A file on the local
-      #   file system that will be uploaded as this object. 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
+      # @param [String, Pathname, File, Tempfile] source A file on the local file system that will be uploaded as
+      #   this object. 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 [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.
+      #   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
-      #   than or equal to `:multipart_threshold` are uploaded using the S3
-      #   multipart APIs.
-      #   Default threshold is 100MB.
+      # @option options [Integer] :multipart_threshold (104857600) Files larger han or equal to
+      #  `:multipart_threshold` are uploaded using the S3 multipart 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) The number of parallel multipart uploads.
+      #    This option is not used if the file is smaller than `:multipart_threshold`.
       #
       # @option options [Proc] :progress_callback
       #   A Proc that will be called when each chunk of the upload is sent.
       #   It will be invoked with [bytes_read], [total_sizes]
       #
-      # @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.
+      # @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.
+      # @return [Boolean] Returns `true` when the object is uploaded without any errors.
       #
       # @see Client#put_object
       # @see Client#create_multipart_upload
@@ -469,15 +458,9 @@ module Aws
       # @see Client#upload_part
       def upload_file(source, options = {})
         uploading_options = options.dup
-        uploader = FileUploader.new(
-          multipart_threshold: uploading_options.delete(:multipart_threshold),
-          client: client
-        )
+        uploader = FileUploader.new(multipart_threshold: uploading_options.delete(:multipart_threshold), client: client)
         response = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
-          uploader.upload(
-            source,
-            uploading_options.merge(bucket: bucket_name, key: key)
-          )
+          uploader.upload(source, uploading_options.merge(bucket: bucket_name, key: key))
         end
         yield response if block_given?
         true
@@ -488,7 +471,7 @@ module Aws
       #     # small files (< 5MB) are downloaded in a single API call
       #     obj.download_file('/path/to/file')
       #
-      # Files larger than 5MB are downloaded using multipart method
+      # Files larger than 5MB are downloaded using multipart method:
       #
       #     # large files are split into parts
       #     # and the parts are downloaded in parallel
@@ -498,64 +481,56 @@ module Aws
       #
       #     # 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.new do |bytes, part_sizes, file_size|
-      #       puts bytes.map.with_index { |b, i| "Part #{i+1}: #{b} / #{part_sizes[i]}"}.join(' ') + "Total: #{100.0 * bytes.sum / file_size}%" }
+      #     progress = proc do |bytes, part_sizes, file_size|
+      #       puts bytes.map.with_index { |b, i| "Part #{i + 1}: #{b} / #{part_sizes[i]}" }.join(' ') + "Total: #{100.0 * bytes.sum / file_size}%"
       #     end
       #     obj.download_file('/path/to/file', progress_callback: progress)
       #
       # @param [String] destination Where to download the file to.
       #
       # @param [Hash] options
-      #   Additional options for {Client#get_object} and #{Client#head_object}
-      #   may be provided.
+      #   Additional options for {Client#get_object} and #{Client#head_object} may be provided.
       #
-      # @option options [String] mode `auto`, `single_request`, `get_range`
-      #  `single_request` mode forces only 1 GET request is made in download,
-      #  `get_range` mode allows `chunk_size` parameter to configured in
-      #  customizing each range size in multipart_download,
-      #  By default, `auto` mode is enabled, which performs multipart_download
+      # @option options [String] :mode ("auto") `"auto"`, `"single_request"` or `"get_range"`
       #
-      # @option options [Integer] chunk_size required in get_range mode.
+      #  * `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] thread_count (10) Customize threads used in
-      #   the multipart download.
+      # @option options [Integer] :chunk_size required in `"get_range"` mode.
       #
-      # @option options [String] version_id The object version id used to
-      #   retrieve the object. For more about object versioning, see:
-      #   https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html
+      # @option options [Integer] :thread_count (10) Customize threads used in the multipart download.
       #
-      # @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 [String] :version_id The object version id used to retrieve the object.
       #
-      # @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.
+      #     @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.
+      #   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.
       #
-      # @return [Boolean] Returns `true` when the file is downloaded without
-      #   any errors.
+      # @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, options = {})
         downloader = FileDownloader.new(client: client)
         Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
-          downloader.download(
-            destination,
-            options.merge(bucket: bucket_name, key: key)
-          )
+          downloader.download(destination, options.merge(bucket: bucket_name, key: key))
         end
         true
       end

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

@@ -10,6 +10,7 @@ module Aws
     autoload :FileUploader, 'aws-sdk-s3/file_uploader'
     autoload :FileDownloader, 'aws-sdk-s3/file_downloader'
     autoload :LegacySigner, 'aws-sdk-s3/legacy_signer'
+    autoload :MultipartDownloadError, 'aws-sdk-s3/multipart_download_error'
     autoload :MultipartFileUploader, 'aws-sdk-s3/multipart_file_uploader'
     autoload :MultipartStreamUploader, 'aws-sdk-s3/multipart_stream_uploader'
     autoload :MultipartUploadError, 'aws-sdk-s3/multipart_upload_error'

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 require 'pathname'
-require 'thread'
+require 'securerandom'
 require 'set'
-require 'tmpdir'
 
 module Aws
   module S3
@@ -12,7 +11,6 @@ module Aws
 
       MIN_CHUNK_SIZE = 5 * 1024 * 1024
       MAX_PARTS = 10_000
-      THREAD_COUNT = 10
 
       def initialize(options = {})
         @client = options[:client] || Client.new
@@ -23,17 +21,12 @@ module Aws
 
       def download(destination, options = {})
         @path = destination
-        @mode = options[:mode] || 'auto'
-        @thread_count = options[:thread_count] || THREAD_COUNT
-        @chunk_size = options[:chunk_size]
-        @params = {
-          bucket: options[:bucket],
-          key: options[:key]
-        }
-        @params[:version_id] = options[:version_id] if options[:version_id]
-        @on_checksum_validated = options[:on_checksum_validated]
-        @progress_callback = options[:progress_callback]
-
+        @mode = options.delete(:mode) || 'auto'
+        @thread_count = options.delete(:thread_count) || 10
+        @chunk_size = options.delete(:chunk_size)
+        @on_checksum_validated = options.delete(:on_checksum_validated)
+        @progress_callback = options.delete(:progress_callback)
+        @params = options
         validate!
 
         Aws::Plugins::UserAgent.metric('S3_TRANSFER') do
@@ -41,32 +34,31 @@ module Aws
           when 'auto' then multipart_download
           when 'single_request' then single_request
           when 'get_range'
-            if @chunk_size
-              resp = @client.head_object(@params)
-              multithreaded_get_by_ranges(resp.content_length, resp.etag)
-            else
-              msg = 'In :get_range mode, :chunk_size must be provided'
-              raise ArgumentError, msg
-            end
+            raise ArgumentError, 'In get_range mode, :chunk_size must be provided' unless @chunk_size
+
+            resp = @client.head_object(@params)
+            multithreaded_get_by_ranges(resp.content_length, resp.etag)
           else
-            msg = "Invalid mode #{@mode} provided, "\
-                  'mode should be :single_request, :get_range or :auto'
-            raise ArgumentError, msg
+            raise ArgumentError, "Invalid mode #{@mode} provided, :mode should be single_request, get_range or auto"
           end
         end
+        File.rename(@temp_path, @path) if @temp_path
+      ensure
+        File.delete(@temp_path) if @temp_path && File.exist?(@temp_path)
       end
 
       private
 
       def validate!
-        if @on_checksum_validated && !@on_checksum_validated.respond_to?(:call)
-          raise ArgumentError, 'on_checksum_validated must be callable'
-        end
+        return unless @on_checksum_validated && !@on_checksum_validated.respond_to?(:call)
+
+        raise ArgumentError, ':on_checksum_validated must be callable'
       end
 
       def multipart_download
         resp = @client.head_object(@params.merge(part_number: 1))
         count = resp.parts_count
+
         if count.nil? || count <= 1
           if resp.content_length <= MIN_CHUNK_SIZE
             single_request
@@ -74,8 +66,8 @@ module Aws
             multithreaded_get_by_ranges(resp.content_length, resp.etag)
           end
         else
-          # partNumber is an option
-          resp = @client.head_object(@params)
+          # covers cases when given object is not uploaded via UploadPart API
+          resp = @client.head_object(@params) # partNumber is an option
           if resp.content_length <= MIN_CHUNK_SIZE
             single_request
           else
@@ -86,7 +78,7 @@ module Aws
 
       def compute_mode(file_size, count, etag)
         chunk_size = compute_chunk(file_size)
-        part_size = (file_size.to_f / count.to_f).ceil
+        part_size = (file_size.to_f / count).ceil
         if chunk_size < part_size
           multithreaded_get_by_ranges(file_size, etag)
         else
@@ -94,32 +86,10 @@ module Aws
         end
       end
 
-      def construct_chunks(file_size)
-        offset = 0
-        default_chunk_size = compute_chunk(file_size)
-        chunks = []
-        while offset < file_size
-          progress = offset + default_chunk_size
-          progress = file_size if progress > file_size
-          chunks << "bytes=#{offset}-#{progress - 1}"
-          offset = progress
-        end
-        chunks
-      end
-
       def compute_chunk(file_size)
-        if @chunk_size && @chunk_size > file_size
-          raise ArgumentError, ":chunk_size shouldn't exceed total file size."
-        else
-          @chunk_size || [
-            (file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE
-          ].max.to_i
-        end
-      end
+        raise ArgumentError, ":chunk_size shouldn't exceed total file size." if @chunk_size && @chunk_size > file_size
 
-      def batches(chunks, mode)
-        chunks = (1..chunks) if mode.eql? 'part_number'
-        chunks.each_slice(@thread_count).to_a
+        @chunk_size || [(file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE].max.to_i
       end
 
       def multithreaded_get_by_ranges(file_size, etag)
@@ -130,12 +100,8 @@ module Aws
         while offset < file_size
           progress = offset + default_chunk_size
           progress = file_size if progress > file_size
-          range = "bytes=#{offset}-#{progress - 1}"
-          chunks << Part.new(
-            part_number: part_number,
-            size: (progress-offset),
-            params: @params.merge(range: range, if_match: etag)
-          )
+          params = @params.merge(range: "bytes=#{offset}-#{progress - 1}", if_match: etag)
+          chunks << Part.new(part_number: part_number, size: (progress - offset), params: params)
           part_number += 1
           offset = progress
         end
@@ -152,10 +118,11 @@ module Aws
       def download_in_threads(pending, total_size)
         threads = []
         progress = MultipartProgress.new(pending, total_size, @progress_callback) if @progress_callback
+        @temp_path = "#{@path}.s3tmp.#{SecureRandom.alphanumeric(8)}"
         @thread_count.times do
           thread = Thread.new do
             begin
-              while part = pending.shift
+              while (part = pending.shift)
                 if progress
                   part.params[:on_chunk_received] =
                     proc do |_chunk, bytes, total|
@@ -163,16 +130,17 @@ module Aws
                     end
                 end
                 resp = @client.get_object(part.params)
-                write(resp)
+                range = extract_range(resp.content_range)
+                validate_range(range, part.params[:range]) if part.params[:range]
+                write(resp.body, range)
                 if @on_checksum_validated && resp.checksum_validated
                   @on_checksum_validated.call(resp.checksum_validated, resp)
                 end
               end
               nil
-            rescue => error
-              # keep other threads from downloading other parts
-              pending.clear!
-              raise error
+            rescue StandardError => e
+              pending.clear! # keep other threads from downloading other parts
+              raise e
             end
           end
           threads << thread
@@ -180,21 +148,27 @@ module Aws
         threads.map(&:value).compact
       end
 
-      def write(resp)
-        range, _ = resp.content_range.split(' ').last.split('/')
-        head, _ = range.split('-').map {|s| s.to_i}
-        File.write(@path, resp.body.read, head)
+      def extract_range(value)
+        value.match(%r{bytes (?<range>\d+-\d+)/\d+})[:range]
+      end
+
+      def validate_range(actual, expected)
+        return if actual == expected.match(/bytes=(?<range>\d+-\d+)/)[:range]
+
+        raise MultipartDownloadError, "multipart download failed: expected range of #{expected} but got #{actual}"
+      end
+
+      def write(body, range)
+        File.write(@temp_path, body.read, range.split('-').first.to_i)
       end
 
       def single_request
         params = @params.merge(response_target: @path)
         params[:on_chunk_received] = single_part_progress if @progress_callback
         resp = @client.get_object(params)
-
         return resp unless @on_checksum_validated
 
         @on_checksum_validated.call(resp.checksum_validated, resp) if resp.checksum_validated
-
         resp
       end
 
@@ -204,6 +178,7 @@ module Aws
         end
       end
 
+      # @api private
       class Part < Struct.new(:part_number, :size, :params)
         include Aws::Structure
       end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    # Raised when multipart download fails to complete.
+    class MultipartDownloadError < StandardError; end
+  end
+end

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

@@ -10,23 +10,15 @@ module Aws
 
       MIN_PART_SIZE = 5 * 1024 * 1024 # 5MB
 
-      FILE_TOO_SMALL = "unable to multipart upload files smaller than 5MB"
-
       MAX_PARTS = 10_000
 
       THREAD_COUNT = 10
 
-      CREATE_OPTIONS = Set.new(
-        Client.api.operation(:create_multipart_upload).input.shape.member_names
-      )
+      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
-      )
+      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
-      )
+      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|
@@ -52,13 +44,11 @@ module Aws
       #   It will be invoked with [bytes_read], [total_sizes]
       # @return [Seahorse::Client::Response] - the CompleteMultipartUploadResponse
       def upload(source, options = {})
-        if File.size(source) < MIN_PART_SIZE
-          raise ArgumentError, FILE_TOO_SMALL
-        else
-          upload_id = initiate_upload(options)
-          parts = upload_parts(upload_id, source, options)
-          complete_upload(upload_id, parts, options)
-        end
+        raise ArgumentError, 'unable to multipart upload files smaller than 5MB' if File.size(source) < MIN_PART_SIZE
+
+        upload_id = initiate_upload(options)
+        parts = upload_parts(upload_id, source, options)
+        complete_upload(upload_id, parts, source, options)
       end
 
       private
@@ -67,18 +57,21 @@ module Aws
         @client.create_multipart_upload(create_opts(options)).upload_id
       end
 
-      def complete_upload(upload_id, parts, options)
+      def complete_upload(upload_id, parts, source, options)
         @client.complete_multipart_upload(
           **complete_opts(options).merge(
             upload_id: upload_id,
-            multipart_upload: { parts: parts }
+            multipart_upload: { parts: parts },
+            mpu_object_size: File.size(source)
           )
         )
+      rescue StandardError => e
+        abort_upload(upload_id, options, [e])
       end
 
       def upload_parts(upload_id, source, options)
-        pending = PartList.new(compute_parts(upload_id, source, options))
         completed = PartList.new
+        pending = PartList.new(compute_parts(upload_id, source, options))
         errors = upload_in_threads(pending, completed, options)
         if errors.empty?
           completed.to_a.sort_by { |part| part[:part_number] }
@@ -88,19 +81,15 @@ module Aws
       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 compute_parts(upload_id, source, options)
@@ -113,11 +102,7 @@ module Aws
           parts << upload_part_opts(options).merge(
             upload_id: upload_id,
             part_number: part_number,
-            body: FilePart.new(
-              source: source,
-              offset: offset,
-              size: part_size(size, default_part_size, offset)
-            )
+            body: FilePart.new(source: source, offset: offset, size: part_size(size, default_part_size, offset))
           )
           part_number += 1
           offset += default_part_size
@@ -136,28 +121,23 @@ module Aws
       def create_opts(options)
         opts = { checksum_algorithm: Aws::Plugins::ChecksumAlgorithm::DEFAULT_CHECKSUM }
         opts[:checksum_type] = 'FULL_OBJECT' if has_checksum_key?(options.keys)
-        CREATE_OPTIONS.inject(opts) do |hash, key|
+        CREATE_OPTIONS.each_with_object(opts) do |key, hash|
           hash[key] = options[key] if options.key?(key)
-          hash
         end
       end
 
       def complete_opts(options)
         opts = {}
         opts[:checksum_type] = 'FULL_OBJECT' if has_checksum_key?(options.keys)
-        COMPLETE_OPTIONS.inject(opts) do |hash, key|
+        COMPLETE_OPTIONS.each_with_object(opts) 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|
-          if options.key?(key)
-            # don't pass through checksum calculations
-            hash[key] = options[key] unless checksum_key?(key)
-          end
-          hash
+        UPLOAD_PART_OPTIONS.each_with_object({}) do |key, hash|
+          # don't pass through checksum calculations
+          hash[key] = options[key] if options.key?(key) && !checksum_key?(key)
         end
       end
 
@@ -169,7 +149,7 @@ module Aws
         options.fetch(:thread_count, @thread_count).times do
           thread = Thread.new do
             begin
-              while part = pending.shift
+              while (part = pending.shift)
                 if progress
                   part[:on_chunk_sent] =
                     proc do |_chunk, bytes, _total|
@@ -178,20 +158,17 @@ module Aws
                 end
                 resp = @client.upload_part(part)
                 part[:body].close
-                completed_part = {
-                  etag: resp.etag,
-                  part_number: part[:part_number]
-                }
+                completed_part = { etag: resp.etag, part_number: part[:part_number] }
                 algorithm = resp.context.params[:checksum_algorithm]
                 k = "checksum_#{algorithm.downcase}".to_sym
                 completed_part[k] = resp.send(k)
                 completed.push(completed_part)
               end
               nil
-            rescue => error
+            rescue StandardError => e
               # keep other threads from uploading other parts
               pending.clear!
-              error
+              e
             end
           end
           threads << thread
@@ -213,7 +190,6 @@ module Aws
 
       # @api private
       class PartList
-
         def initialize(parts = [])
           @parts = parts
           @mutex = Mutex.new
@@ -242,7 +218,6 @@ module Aws
         def to_a
           @mutex.synchronize { @parts.dup }
         end
-
       end
 
       # @api private
@@ -261,4 +236,4 @@ module Aws
       end
     end
   end
-end
+end

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

@@ -2,17 +2,16 @@
 
 module Aws
   module S3
+    # Raise when multipart upload fails to complete.
     class MultipartUploadError < StandardError
 
-      def initialize(message, errors)
+      def initialize(message, errors = [])
         @errors = errors
         super(message)
       end
 
-      # @return [Array<StandardError>] The list of errors encountered
-      #   when uploading or aborting the upload.
+      # @return [Array<StandardError>] The list of errors encountered when uploading or aborting the upload.
       attr_reader :errors
-
     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.0'
+  GEM_VERSION = '1.196.1'
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-s3
 version: !ruby/object:Gem::Version
-  version: 1.196.0
+  version: 1.196.1
 platform: ruby
 authors:
 - Amazon Web Services
@@ -134,6 +134,7 @@ files:
 - lib/aws-sdk-s3/file_part.rb
 - lib/aws-sdk-s3/file_uploader.rb
 - lib/aws-sdk-s3/legacy_signer.rb
+- lib/aws-sdk-s3/multipart_download_error.rb
 - lib/aws-sdk-s3/multipart_file_uploader.rb
 - lib/aws-sdk-s3/multipart_stream_uploader.rb
 - lib/aws-sdk-s3/multipart_upload.rb