aws-sdk-s3 1.48.0 → 1.169.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Aws
@@ -5,44 +7,49 @@ module Aws
     # @api private
     class FileUploader
 
-      FIFTEEN_MEGABYTES = 15 * 1024 * 1024
+      ONE_HUNDRED_MEGABYTES = 100 * 1024 * 1024
 
+      # @param [Hash] options
       # @option options [Client] :client
-      # @option options [Integer] :multipart_threshold Files greater than
-      #   `:multipart_threshold` bytes are uploaded using S3 multipart APIs.
+      # @option options [Integer] :multipart_threshold (104857600)
       def initialize(options = {})
         @options = options
         @client = options[:client] || Client.new
-        @multipart_threshold = options[:multipart_threshold] || FIFTEEN_MEGABYTES
+        @multipart_threshold = options[:multipart_threshold] ||
+                               ONE_HUNDRED_MEGABYTES
       end
 
       # @return [Client]
       attr_reader :client
 
-      # @return [Integer] Files larger than this in bytes are uploaded
+      # @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
-      # @option options [required,String] :bucket
-      # @option options [required,String] :key
+      # @param [String, Pathname, File, Tempfile] source The file to upload.
+      # @option options [required, String] :bucket The bucket to upload to.
+      # @option options [required, String] :key The key for the object.
+      # @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]
+      # @option options [Integer] :thread_count
+      #   The thread count to use for multipart uploads. Ignored for
+      #   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
-          put_object(source, options)
+        Aws::Plugins::UserAgent.metric('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
 
       private
 
-      def put_object(source, options)
-        open_file(source) do |file|
-          @client.put_object(options.merge(body: file))
-        end
-      end
-
       def open_file(source)
         if String === source || Pathname === source
           File.open(source, 'rb') { |file| yield(file) }
@@ -51,6 +58,20 @@ module Aws
         end
       end
 
+      def put_object(source, options)
+        if (callback = options.delete(:progress_callback))
+          options[:on_chunk_sent] = single_part_progress(callback)
+        end
+        open_file(source) do |file|
+          @client.put_object(options.merge(body: file))
+        end
+      end
+
+      def single_part_progress(progress_callback)
+        proc do |_chunk, bytes_read, total_size|
+          progress_callback.call([bytes_read], [total_size])
+        end
+      end
     end
   end
 end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'time'
 require 'openssl'
 require 'cgi'
-require 'webrick/httputils'
 require 'aws-sdk-core/query'
 
 module Aws
@@ -155,33 +156,24 @@ module Aws
       end
 
       def uri_escape(s)
-
         #URI.escape(s)
 
-        # URI.escape is deprecated, replacing it with escape from webrick
-        # to squelch the massive number of warnings generated from Ruby.
-        # The following script was used to determine the differences
-        # between the various escape methods available. The webrick
-        # escape only had two differences and it is available in the
-        # standard lib.
-        #
-        #     (0..255).each {|c|
-        #       s = [c].pack("C")
-        #       e = [
-        #         CGI.escape(s),
-        #         ERB::Util.url_encode(s),
-        #         URI.encode_www_form_component(s),
-        #         WEBrick::HTTPUtils.escape_form(s),
-        #         WEBrick::HTTPUtils.escape(s),
-        #         URI.escape(s),
-        #       ]
-        #       next if e.uniq.length == 1
-        #       puts("%5s %5s %5s %5s %5s %5s %5s" % ([s.inspect] + e))
-        #     }
-        #
-        WEBrick::HTTPUtils.escape(s).gsub('%5B', '[').gsub('%5D', ']')
+        # (0..255).each {|c|
+        #   s = [c].pack("C")
+        #   e = [
+        #     CGI.escape(s),
+        #     ERB::Util.url_encode(s),
+        #     URI.encode_www_form_component(s),
+        #     WEBrick::HTTPUtils.escape_form(s),
+        #     WEBrick::HTTPUtils.escape(s),
+        #     URI.escape(s),
+        #     URI::DEFAULT_PARSER.escape(s)
+        #   ]
+        #   next if e.uniq.length == 1
+        #   puts("%5s %5s %5s %5s %5s %5s %5s %5s" % ([s.inspect] + e))
+        # }
+        URI::DEFAULT_PARSER.escape(s)
       end
-
     end
   end
 end

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

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require 'pathname'
-require 'thread'
 require 'set'
 
 module Aws
@@ -16,14 +17,21 @@ module Aws
       THREAD_COUNT = 10
 
       # @api private
-      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
+      )
 
       # @api private
-      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
+      )
 
       # @option options [Client] :client
+      # @option options [Integer] :thread_count (THREAD_COUNT)
       def initialize(options = {})
         @client = options[:client] || Client.new
         @thread_count = options[:thread_count] || THREAD_COUNT
@@ -32,10 +40,13 @@ module Aws
       # @return [Client]
       attr_reader :client
 
-      # @param [String,Pathname,File,Tempfile] source
-      # @option options [required,String] :bucket
-      # @option options [required,String] :key
-      # @return [void]
+      # @param [String, Pathname, File, Tempfile] source The file to upload.
+      # @option options [required, String] :bucket The bucket to upload to.
+      # @option options [required, String] :key The key for the object.
+      # @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]
+      # @return [Seahorse::Client::Response] - the CompleteMultipartUploadResponse
       def upload(source, options = {})
         if File.size(source) < MIN_PART_SIZE
           raise ArgumentError, FILE_TOO_SMALL
@@ -54,16 +65,17 @@ 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, source, options)
         pending = PartList.new(compute_parts(upload_id, source, options))
         completed = PartList.new
-        errors = upload_in_threads(pending, completed)
+        errors = upload_in_threads(pending, completed, options)
         if errors.empty?
           completed.to_a.sort_by { |part| part[:part_number] }
         else
@@ -77,12 +89,13 @@ module Aws
           key: options[:key],
           upload_id: upload_id
         )
-        msg = "multipart upload failed: #{errors.map(&:message).join("; ")}"
+        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}"
+        msg = "failed to abort multipart upload: #{error.message}. "\
+          "Multipart upload failed: #{errors.map(&:message).join('; ')}"
         raise MultipartUploadError.new(msg, errors + [error])
       end
 
@@ -93,7 +106,7 @@ module Aws
         part_number = 1
         parts = []
         while offset < size
-          parts << upload_part_opts(options).merge({
+          parts << upload_part_opts(options).merge(
             upload_id: upload_id,
             part_number: part_number,
             body: FilePart.new(
@@ -101,7 +114,7 @@ module Aws
               offset: offset,
               size: part_size(size, default_part_size, offset)
             )
-          })
+          )
           part_number += 1
           offset += default_part_size
         end
@@ -115,6 +128,13 @@ module Aws
         end
       end
 
+      def complete_opts(options)
+        COMPLETE_OPTIONS.inject({}) do |hash, key|
+          hash[key] = options[key] if options.key?(key)
+          hash
+        end
+      end
+
       def upload_part_opts(options)
         UPLOAD_PART_OPTIONS.inject({}) do |hash, key|
           hash[key] = options[key] if options.key?(key)
@@ -122,15 +142,32 @@ module Aws
         end
       end
 
-      def upload_in_threads(pending, completed)
+      def upload_in_threads(pending, completed, options)
         threads = []
-        @thread_count.times do
+        if (callback = options[:progress_callback])
+          progress = MultipartProgress.new(pending, callback)
+        end
+        options.fetch(:thread_count, @thread_count).times do
           thread = Thread.new do
             begin
               while part = pending.shift
+                if progress
+                  part[:on_chunk_sent] =
+                    proc do |_chunk, bytes, _total|
+                      progress.call(part[:part_number], bytes)
+                    end
+                end
                 resp = @client.upload_part(part)
                 part[:body].close
-                completed.push(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)
               end
               nil
             rescue => error
@@ -139,7 +176,6 @@ module Aws
               error
             end
           end
-          thread.abort_on_exception = true
           threads << thread
         end
         threads.map(&:value).compact
@@ -177,11 +213,34 @@ module Aws
           @mutex.synchronize { @parts.clear }
         end
 
+        def size
+          @mutex.synchronize { @parts.size }
+        end
+
+        def part_sizes
+          @mutex.synchronize { @parts.map { |p| p[:body].size } }
+        end
+
         def to_a
           @mutex.synchronize { @parts.dup }
         end
 
       end
+
+      # @api private
+      class MultipartProgress
+        def initialize(parts, progress_callback)
+          @bytes_sent = Array.new(parts.size, 0)
+          @total_sizes = parts.part_sizes
+          @progress_callback = progress_callback
+        end
+
+        def call(part_number, bytes_read)
+          # part numbers start at 1
+          @bytes_sent[part_number - 1] = bytes_read
+          @progress_callback.call(@bytes_sent, @total_sizes)
+        end
+      end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread'
 require 'set'
 require 'tempfile'
@@ -24,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
@@ -37,11 +43,14 @@ module Aws
 
       # @option options [required,String] :bucket
       # @option options [required,String] :key
-      # @return [void]
+      # @option options [Integer] :thread_count (THREAD_COUNT)
+      # @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.metric('S3_TRANSFER') do
+          upload_id = initiate_upload(options)
+          parts = upload_parts(upload_id, options, &block)
+          complete_upload(upload_id, parts, options)
+        end
       end
 
       private
@@ -52,20 +61,34 @@ 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
-        errors = IO.pipe do |read_pipe, write_pipe|
-          threads = upload_in_threads(read_pipe, completed, upload_part_opts(options).merge(upload_id: upload_id))
-          block.call(write_pipe)
-          write_pipe.close
-          threads.map(&:value).compact
+        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),
+              thread_errors)
+            begin
+              block.call(write_pipe)
+            ensure
+              # Ensure the pipe is closed to avoid https://github.com/jruby/jruby/issues/6111
+              write_pipe.close
+            end
+            threads.map(&:value).compact
+          end
+        rescue => e
+          thread_errors + [e]
         end
+
         if errors.empty?
           Array.new(completed.size) { completed.pop }.sort_by { |part| part[:part_number] }
         else
@@ -79,12 +102,13 @@ module Aws
           key: options[:key],
           upload_id: upload_id
         )
-        msg = "multipart upload failed: #{errors.map(&:message).join("; ")}"
+        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}"
+        msg = "failed to abort multipart upload: #{error.message}. "\
+          "Multipart upload failed: #{errors.map(&:message).join('; ')}"
         raise MultipartUploadError.new(msg, errors + [error])
       end
 
@@ -102,9 +126,16 @@ 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
+        temp_io = @tempfile ? Tempfile.new(TEMPFILE_PREIX) : StringIO.new(String.new)
         temp_io.binmode
         bytes_copied = IO.copy_stream(read_pipe, temp_io, @part_size)
         temp_io.rewind
@@ -119,10 +150,10 @@ 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
+        options.fetch(:thread_count, @thread_count).times.map do
           thread = Thread.new do
             begin
               loop do
@@ -136,7 +167,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
@@ -149,11 +187,13 @@ module Aws
               nil
             rescue => error
               # keep other threads from uploading other parts
-              mutex.synchronize { read_pipe.close_read }
+              mutex.synchronize do
+                thread_errors.push(error)
+                read_pipe.close_read unless read_pipe.closed?
+              end
               error
             end
           end
-          thread.abort_on_exception = true
           thread
         end
       end