aws-sdk-s3 1.193.0 → 1.198.0

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_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

@@ -9,25 +9,11 @@ module Aws
     class MultipartFileUploader
 
       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
-      )
-
-      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
-      )
-
+      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-')
@@ -35,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]
@@ -52,13 +38,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 +51,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 +75,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 +96,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 +115,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 +143,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 +152,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 +184,6 @@ module Aws
 
       # @api private
       class PartList
-
         def initialize(parts = [])
           @parts = parts
           @mutex = Mutex.new
@@ -242,7 +212,6 @@ module Aws
         def to_a
           @mutex.synchronize { @parts.dup }
         end
-
       end
 
       # @api private
@@ -261,4 +230,4 @@ module Aws
       end
     end
   end
-end
+end

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/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