aws-sdk-s3 1.114.0 → 1.136.0

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

@@ -32,39 +32,68 @@ module Aws
         }
         @params[:version_id] = options[:version_id] if options[:version_id]
 
-        case @mode
-        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(construct_chunks(resp.content_length))
+        # checksum_mode only supports the value "ENABLED"
+        # falsey values (false/nil) or "DISABLED" should be considered
+        # disabled and the api parameter should be unset.
+        if (checksum_mode = options.fetch(:checksum_mode, 'ENABLED'))
+          @params[:checksum_mode] = checksum_mode unless checksum_mode.upcase == 'DISABLED'
+        end
+        @on_checksum_validated = options[:on_checksum_validated]
+
+        @progress_callback = options[:progress_callback]
+
+        validate!
+
+        Aws::Plugins::UserAgent.feature('s3-transfer') do
+          case @mode
+          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)
+            else
+              msg = 'In :get_range mode, :chunk_size must be provided'
+              raise ArgumentError, msg
+            end
           else
-            msg = 'In :get_range mode, :chunk_size must be provided'
+            msg = "Invalid mode #{@mode} provided, "\
+                  'mode should be :single_request, :get_range or :auto'
             raise ArgumentError, msg
           end
-        else
-          msg = "Invalid mode #{@mode} provided, "\
-                'mode should be :single_request, :get_range or :auto'
-          raise ArgumentError, msg
         end
       end
 
       private
 
+      def validate!
+        if @on_checksum_validated && @params[:checksum_mode] != 'ENABLED'
+          raise ArgumentError, "You must set checksum_mode: 'ENABLED' " +
+            "when providing a on_checksum_validated callback"
+        end
+
+        if @on_checksum_validated && !@on_checksum_validated.respond_to?(:call)
+          raise ArgumentError, 'on_checksum_validated must be callable'
+        end
+      end
+
       def multipart_download
         resp = @client.head_object(@params.merge(part_number: 1))
         count = resp.parts_count
         if count.nil? || count <= 1
-          resp.content_length < MIN_CHUNK_SIZE ?
-            single_request :
-            multithreaded_get_by_ranges(construct_chunks(resp.content_length))
+          if resp.content_length <= MIN_CHUNK_SIZE
+            single_request
+          else
+            multithreaded_get_by_ranges(resp.content_length)
+          end
         else
           # partNumber is an option
           resp = @client.head_object(@params)
-          resp.content_length < MIN_CHUNK_SIZE ?
-            single_request :
+          if resp.content_length <= MIN_CHUNK_SIZE
+            single_request
+          else
             compute_mode(resp.content_length, count)
+          end
         end
       end
 
@@ -72,9 +101,9 @@ module Aws
         chunk_size = compute_chunk(file_size)
         part_size = (file_size.to_f / count.to_f).ceil
         if chunk_size < part_size
-          multithreaded_get_by_ranges(construct_chunks(file_size))
+          multithreaded_get_by_ranges(file_size)
         else
-          multithreaded_get_by_parts(count)
+          multithreaded_get_by_parts(count, file_size)
         end
       end
 
@@ -82,10 +111,11 @@ module Aws
         offset = 0
         default_chunk_size = compute_chunk(file_size)
         chunks = []
-        while offset <= file_size
+        while offset < file_size
           progress = offset + default_chunk_size
-          chunks << "bytes=#{offset}-#{progress < file_size ? progress : file_size}"
-          offset = progress + 1
+          progress = file_size if progress > file_size
+          chunks << "bytes=#{offset}-#{progress - 1}"
+          offset = progress
         end
         chunks
       end
@@ -94,12 +124,9 @@ module Aws
         if @chunk_size && @chunk_size > file_size
           raise ArgumentError, ":chunk_size shouldn't exceed total file size."
         else
-          chunk_size = @chunk_size || [
-            (file_size.to_f / MAX_PARTS).ceil,
-            MIN_CHUNK_SIZE
+          @chunk_size || [
+            (file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE
           ].max.to_i
-          chunk_size -= 1 if file_size % chunk_size == 1
-          chunk_size
         end
       end
 
@@ -108,27 +135,65 @@ module Aws
         chunks.each_slice(@thread_count).to_a
       end
 
-      def multithreaded_get_by_ranges(chunks)
-        thread_batches(chunks, 'range')
+      def multithreaded_get_by_ranges(file_size)
+        offset = 0
+        default_chunk_size = compute_chunk(file_size)
+        chunks = []
+        part_number = 1 # parts start at 1
+        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)
+          )
+          part_number += 1
+          offset = progress
+        end
+        download_in_threads(PartList.new(chunks), file_size)
       end
 
-      def multithreaded_get_by_parts(parts)
-        thread_batches(parts, 'part_number')
+      def multithreaded_get_by_parts(n_parts, total_size)
+        parts = (1..n_parts).map do |part|
+          Part.new(part_number: part, params: @params.merge(part_number: part))
+        end
+        download_in_threads(PartList.new(parts), total_size)
       end
 
-      def thread_batches(chunks, param)
-        batches(chunks, param).each do |batch|
-          threads = []
-          batch.each do |chunk|
-            threads << Thread.new do
-              resp = @client.get_object(
-                @params.merge(param.to_sym => chunk)
-              )
-              write(resp)
+      def download_in_threads(pending, total_size)
+        threads = []
+        if @progress_callback
+          progress = MultipartProgress.new(pending, total_size, @progress_callback)
+        end
+        @thread_count.times do
+          thread = Thread.new do
+            begin
+              while part = pending.shift
+                if progress
+                  part.params[:on_chunk_received] =
+                    proc do |_chunk, bytes, total|
+                      progress.call(part.part_number, bytes, total)
+                    end
+                end
+                resp = @client.get_object(part.params)
+                write(resp)
+                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
             end
           end
-          threads.each(&:join)
+          thread.abort_on_exception = true
+          threads << thread
         end
+        threads.map(&:value).compact
       end
 
       def write(resp)
@@ -138,9 +203,70 @@ module Aws
       end
 
       def single_request
-        @client.get_object(
-          @params.merge(response_target: @path)
-        )
+        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
+
+        if resp.checksum_validated
+          @on_checksum_validated.call(resp.checksum_validated, resp)
+        end
+
+        resp
+      end
+
+      def single_part_progress
+        proc do |_chunk, bytes_read, total_size|
+          @progress_callback.call([bytes_read], [total_size], total_size)
+        end
+      end
+
+      class Part < Struct.new(:part_number, :size, :params)
+        include Aws::Structure
+      end
+
+      # @api private
+      class PartList
+        include Enumerable
+        def initialize(parts = [])
+          @parts = parts
+          @mutex = Mutex.new
+        end
+
+        def shift
+          @mutex.synchronize { @parts.shift }
+        end
+
+        def size
+          @mutex.synchronize { @parts.size }
+        end
+
+        def clear!
+          @mutex.synchronize { @parts.clear }
+        end
+
+        def each(&block)
+          @mutex.synchronize { @parts.each(&block) }
+        end
+      end
+
+      # @api private
+      class  MultipartProgress
+        def initialize(parts, total_size, progress_callback)
+          @bytes_received = Array.new(parts.size, 0)
+          @part_sizes = parts.map(&:size)
+          @total_size = total_size
+          @progress_callback = progress_callback
+        end
+
+        def call(part_number, bytes_received, total)
+          # part numbers start at 1
+          @bytes_received[part_number - 1] = bytes_received
+          # part size may not be known until we get the first response
+          @part_sizes[part_number - 1] ||= total
+          @progress_callback.call(@bytes_received, @part_sizes, @total_size)
+        end
       end
     end
   end

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

@@ -37,12 +37,14 @@ module Aws
       #   objects smaller than the multipart threshold.
       # @return [void]
       def upload(source, options = {})
-        if File.size(source) >= multipart_threshold
-          MultipartFileUploader.new(@options).upload(source, options)
-        else
-          # remove multipart parameters not supported by put_object
-          options.delete(:thread_count)
-          put_object(source, options)
+        Aws::Plugins::UserAgent.feature('s3-transfer') do
+          if File.size(source) >= multipart_threshold
+            MultipartFileUploader.new(@options).upload(source, options)
+          else
+            # remove multipart parameters not supported by put_object
+            options.delete(:thread_count)
+            put_object(source, options)
+          end
         end
       end
 

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

@@ -26,6 +26,10 @@ module Aws
       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)
+
       # @option options [Client] :client
       def initialize(options = {})
         @client = options[:client] || Client.new
@@ -39,11 +43,13 @@ module Aws
 
       # @option options [required,String] :bucket
       # @option options [required,String] :key
-      # @return [void]
+      # @return [Seahorse::Client::Response] - the CompleteMultipartUploadResponse
       def upload(options = {}, &block)
-        upload_id = initiate_upload(options)
-        parts = upload_parts(upload_id, options, &block)
-        complete_upload(upload_id, parts, options)
+        Aws::Plugins::UserAgent.feature('s3-transfer') do
+          upload_id = initiate_upload(options)
+          parts = upload_parts(upload_id, options, &block)
+          complete_upload(upload_id, parts, options)
+        end
       end
 
       private
@@ -54,17 +60,22 @@ module Aws
 
       def complete_upload(upload_id, parts, options)
         @client.complete_multipart_upload(
-          bucket: options[:bucket],
-          key: options[:key],
-          upload_id: upload_id,
-          multipart_upload: { parts: parts })
+          **complete_opts(options).merge(
+            upload_id: upload_id,
+            multipart_upload: { parts: parts }
+          )
+        )
       end
 
       def upload_parts(upload_id, options, &block)
         completed = Queue.new
+        thread_errors = []
         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))
+            threads = upload_in_threads(
+              read_pipe, completed,
+              upload_part_opts(options).merge(upload_id: upload_id),
+              thread_errors)
             begin
               block.call(write_pipe)
             ensure
@@ -74,7 +85,7 @@ module Aws
             threads.map(&:value).compact
           end
         rescue => e
-          [e]
+          thread_errors + [e]
         end
 
         if errors.empty?
@@ -113,6 +124,13 @@ module Aws
         end
       end
 
+      def complete_opts(options)
+        COMPLETE_UPLOAD_OPTIONS.inject({}) do |hash, key|
+          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)
@@ -130,7 +148,7 @@ module Aws
         end
       end
 
-      def upload_in_threads(read_pipe, completed, options)
+      def upload_in_threads(read_pipe, completed, options, thread_errors)
         mutex = Mutex.new
         part_number = 0
         @thread_count.times.map do
@@ -147,7 +165,14 @@ module Aws
                     part_number: thread_part_number,
                   )
                   resp = @client.upload_part(part)
-                  completed << {etag: resp.etag, part_number: part[:part_number]}
+                  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
@@ -160,7 +185,10 @@ module Aws
               nil
             rescue => error
               # keep other threads from uploading other parts
-              mutex.synchronize { read_pipe.close_read unless read_pipe.closed? }
+              mutex.synchronize do
+                thread_errors.push(error)
+                read_pipe.close_read unless read_pipe.closed?
+              end
               error
             end
           end

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

@@ -217,7 +217,9 @@ module Aws::S3
           :retry
         end
       end
-      Aws::Waiters::Waiter.new(options).wait({})
+      Aws::Plugins::UserAgent.feature('resource') do
+        Aws::Waiters::Waiter.new(options).wait({})
+      end
     end
 
     # @!group Actions
@@ -232,9 +234,11 @@ module Aws::S3
     # @option options [String] :request_payer
     #   Confirms that the requester knows that they will be charged for the
     #   request. Bucket owners need not specify this parameter in their
-    #   requests. For information about downloading objects from Requester
-    #   Pays buckets, see [Downloading Objects in Requester Pays Buckets][1]
-    #   in the *Amazon S3 User Guide*.
+    #   requests. If either the source or destination Amazon S3 bucket has
+    #   Requester Pays enabled, the requester will pay for corresponding
+    #   charges to copy the object. For information about downloading objects
+    #   from Requester Pays buckets, see [Downloading Objects in Requester
+    #   Pays Buckets][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -250,7 +254,9 @@ module Aws::S3
         key: @object_key,
         upload_id: @id
       )
-      resp = @client.abort_multipart_upload(options)
+      resp = Aws::Plugins::UserAgent.feature('resource') do
+        @client.abort_multipart_upload(options)
+      end
       resp.data
     end
 
@@ -325,9 +331,11 @@ module Aws::S3
     # @option options [String] :request_payer
     #   Confirms that the requester knows that they will be charged for the
     #   request. Bucket owners need not specify this parameter in their
-    #   requests. For information about downloading objects from Requester
-    #   Pays buckets, see [Downloading Objects in Requester Pays Buckets][1]
-    #   in the *Amazon S3 User Guide*.
+    #   requests. If either the source or destination Amazon S3 bucket has
+    #   Requester Pays enabled, the requester will pay for corresponding
+    #   charges to copy the object. For information about downloading objects
+    #   from Requester Pays buckets, see [Downloading Objects in Requester
+    #   Pays Buckets][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -370,7 +378,9 @@ module Aws::S3
         key: @object_key,
         upload_id: @id
       )
-      @client.complete_multipart_upload(options)
+      Aws::Plugins::UserAgent.feature('resource') do
+        @client.complete_multipart_upload(options)
+      end
       Object.new(
         bucket_name: @bucket_name,
         key: @object_key,
@@ -414,9 +424,11 @@ module Aws::S3
     # @option options [String] :request_payer
     #   Confirms that the requester knows that they will be charged for the
     #   request. Bucket owners need not specify this parameter in their
-    #   requests. For information about downloading objects from Requester
-    #   Pays buckets, see [Downloading Objects in Requester Pays Buckets][1]
-    #   in the *Amazon S3 User Guide*.
+    #   requests. If either the source or destination Amazon S3 bucket has
+    #   Requester Pays enabled, the requester will pay for corresponding
+    #   charges to copy the object. For information about downloading objects
+    #   from Requester Pays buckets, see [Downloading Objects in Requester
+    #   Pays Buckets][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -460,7 +472,9 @@ module Aws::S3
           key: @object_key,
           upload_id: @id
         )
-        resp = @client.list_parts(options)
+        resp = Aws::Plugins::UserAgent.feature('resource') do
+          @client.list_parts(options)
+        end
         resp.each_page do |page|
           batch = []
           page.data.parts.each do |p|

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

@@ -256,7 +256,9 @@ module Aws::S3
           :retry
         end
       end
-      Aws::Waiters::Waiter.new(options).wait({})
+      Aws::Plugins::UserAgent.feature('resource') do
+        Aws::Waiters::Waiter.new(options).wait({})
+      end
     end
 
     # @!group Actions
@@ -284,7 +286,7 @@ module Aws::S3
     # @option options [required, String] :copy_source
     #   Specifies the source object for the copy operation. You specify the
     #   value in one of two formats, depending on whether you want to access
-    #   the source object through an [access point][1]\:
+    #   the source object through an [access point][1]:
     #
     #   * For objects not accessed through an access point, specify the name
     #     of the source bucket and key of the source object, separated by a
@@ -372,9 +374,11 @@ module Aws::S3
     # @option options [String] :request_payer
     #   Confirms that the requester knows that they will be charged for the
     #   request. Bucket owners need not specify this parameter in their
-    #   requests. For information about downloading objects from Requester
-    #   Pays buckets, see [Downloading Objects in Requester Pays Buckets][1]
-    #   in the *Amazon S3 User Guide*.
+    #   requests. If either the source or destination Amazon S3 bucket has
+    #   Requester Pays enabled, the requester will pay for corresponding
+    #   charges to copy the object. For information about downloading objects
+    #   from Requester Pays buckets, see [Downloading Objects in Requester
+    #   Pays Buckets][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -395,7 +399,9 @@ module Aws::S3
         upload_id: @multipart_upload_id,
         part_number: @part_number
       )
-      resp = @client.upload_part_copy(options)
+      resp = Aws::Plugins::UserAgent.feature('resource') do
+        @client.upload_part_copy(options)
+      end
       resp.data
     end
 
@@ -502,9 +508,11 @@ module Aws::S3
     # @option options [String] :request_payer
     #   Confirms that the requester knows that they will be charged for the
     #   request. Bucket owners need not specify this parameter in their
-    #   requests. For information about downloading objects from Requester
-    #   Pays buckets, see [Downloading Objects in Requester Pays Buckets][1]
-    #   in the *Amazon S3 User Guide*.
+    #   requests. If either the source or destination Amazon S3 bucket has
+    #   Requester Pays enabled, the requester will pay for corresponding
+    #   charges to copy the object. For information about downloading objects
+    #   from Requester Pays buckets, see [Downloading Objects in Requester
+    #   Pays Buckets][1] in the *Amazon S3 User Guide*.
     #
     #
     #
@@ -521,7 +529,9 @@ module Aws::S3
         upload_id: @multipart_upload_id,
         part_number: @part_number
       )
-      resp = @client.upload_part(options)
+      resp = Aws::Plugins::UserAgent.feature('resource') do
+        @client.upload_part(options)
+      end
       resp.data
     end