aws-sdk-s3 1.167.0 → 1.208.0

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

@@ -29,12 +29,17 @@ module Aws::S3
   # ## Error Classes
   # * {BucketAlreadyExists}
   # * {BucketAlreadyOwnedByYou}
+  # * {EncryptionTypeMismatch}
+  # * {IdempotencyParameterMismatch}
   # * {InvalidObjectState}
+  # * {InvalidRequest}
+  # * {InvalidWriteOffset}
   # * {NoSuchBucket}
   # * {NoSuchKey}
   # * {NoSuchUpload}
   # * {ObjectAlreadyInActiveTierError}
   # * {ObjectNotInActiveTierError}
+  # * {TooManyParts}
   #
   # Additionally, error classes are dynamically generated for service errors based on the error code
   # if they are not defined above.
@@ -62,6 +67,26 @@ module Aws::S3
       end
     end
 
+    class EncryptionTypeMismatch < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::EncryptionTypeMismatch] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class IdempotencyParameterMismatch < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::IdempotencyParameterMismatch] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
     class InvalidObjectState < ServiceError
 
       # @param [Seahorse::Client::RequestContext] context
@@ -82,6 +107,26 @@ module Aws::S3
       end
     end
 
+    class InvalidRequest < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::InvalidRequest] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class InvalidWriteOffset < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::InvalidWriteOffset] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
     class NoSuchBucket < ServiceError
 
       # @param [Seahorse::Client::RequestContext] context
@@ -132,6 +177,16 @@ module Aws::S3
       end
     end
 
+    class TooManyParts < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::TooManyParts] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
   end
 end
 

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

@@ -1,226 +1,270 @@
 # frozen_string_literal: true
 
 require 'pathname'
-require 'thread'
+require 'securerandom'
 require 'set'
-require 'tmpdir'
 
 module Aws
   module S3
     # @api private
     class FileDownloader
-
       MIN_CHUNK_SIZE = 5 * 1024 * 1024
       MAX_PARTS = 10_000
-      THREAD_COUNT = 10
+      HEAD_OPTIONS = Set.new(Client.api.operation(:head_object).input.shape.member_names)
+      GET_OPTIONS = Set.new(Client.api.operation(:get_object).input.shape.member_names)
 
       def initialize(options = {})
         @client = options[:client] || Client.new
+        @executor = options[:executor]
       end
 
       # @return [Client]
       attr_reader :client
 
       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]
+        validate_destination!(destination)
+        opts = build_download_opts(destination, options)
+        validate_opts!(opts)
 
-        # 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'
+        Aws::Plugins::UserAgent.metric('S3_TRANSFER') do
+          case opts[:mode]
+          when 'auto' then multipart_download(opts)
+          when 'single_request' then single_request(opts)
+          when 'get_range' then range_request(opts)
+          end
         end
-        @on_checksum_validated = options[:on_checksum_validated]
+        File.rename(opts[:temp_path], destination) if opts[:temp_path]
+      ensure
+        cleanup_temp_file(opts)
+      end
 
-        @progress_callback = options[:progress_callback]
+      private
 
-        validate!
+      def build_download_opts(destination, opts)
+        {
+          destination: destination,
+          mode: opts.delete(:mode) || 'auto',
+          chunk_size: opts.delete(:chunk_size),
+          on_checksum_validated: opts.delete(:on_checksum_validated),
+          progress_callback: opts.delete(:progress_callback),
+          params: opts,
+          temp_path: nil
+        }
+      end
 
-        Aws::Plugins::UserAgent.metric('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 = "Invalid mode #{@mode} provided, "\
-                  'mode should be :single_request, :get_range or :auto'
-            raise ArgumentError, msg
+      def cleanup_temp_file(opts)
+        return unless opts
+
+        temp_file = opts[:temp_path]
+        File.delete(temp_file) if temp_file && File.exist?(temp_file)
+      end
+
+      def download_with_executor(part_list, total_size, opts)
+        download_attempts = 0
+        completion_queue = Queue.new
+        abort_download = false
+        error = nil
+        progress = MultipartProgress.new(part_list, total_size, opts[:progress_callback])
+
+        while (part = part_list.shift)
+          break if abort_download
+
+          download_attempts += 1
+          @executor.post(part) do |p|
+            update_progress(progress, p)
+            resp = @client.get_object(p.params)
+            range = extract_range(resp.content_range)
+            validate_range(range, p.params[:range]) if p.params[:range]
+            write(resp.body, range, opts)
+
+            execute_checksum_callback(resp, opts)
+          rescue StandardError => e
+            abort_download = true
+            error = e
+          ensure
+            completion_queue << :done
           end
         end
+
+        download_attempts.times { completion_queue.pop }
+        raise error unless error.nil?
       end
 
-      private
+      def handle_checksum_mode_option(option_key, opts)
+        return false unless option_key == :checksum_mode && opts[:checksum_mode] == 'DISABLED'
+
+        msg = ':checksum_mode option is deprecated. Checksums will be validated by default. ' \
+          'To disable checksum validation, set :response_checksum_validation to "when_required" on your S3 client.'
+        warn(msg)
+        true
+      end
+
+      def get_opts(opts)
+        GET_OPTIONS.each_with_object({}) do |k, h|
+          next if k == :checksum_mode
 
-      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"
+          h[k] = opts[k] if opts.key?(k)
         end
+      end
+
+      def head_opts(opts)
+        HEAD_OPTIONS.each_with_object({}) do |k, h|
+          next if handle_checksum_mode_option(k, opts)
+
+          h[k] = opts[k] if opts.key?(k)
+        end
+      end
+
+      def compute_chunk(chunk_size, file_size)
+        raise ArgumentError, ":chunk_size shouldn't exceed total file size." if chunk_size && chunk_size > file_size
+
+        chunk_size || [(file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE].max.to_i
+      end
+
+      def compute_mode(file_size, total_parts, etag, opts)
+        chunk_size = compute_chunk(opts[:chunk_size], file_size)
+        part_size = (file_size.to_f / total_parts).ceil
 
-        if @on_checksum_validated && !@on_checksum_validated.respond_to?(:call)
-          raise ArgumentError, 'on_checksum_validated must be callable'
+        resolve_temp_path(opts)
+        if chunk_size < part_size
+          multithreaded_get_by_ranges(file_size, etag, opts)
+        else
+          multithreaded_get_by_parts(total_parts, file_size, etag, opts)
         end
       end
 
-      def multipart_download
-        resp = @client.head_object(@params.merge(part_number: 1))
+      def extract_range(value)
+        value.match(%r{bytes (?<range>\d+-\d+)/\d+})[:range]
+      end
+
+      def multipart_download(opts)
+        resp = @client.head_object(head_opts(opts[:params].merge(part_number: 1)))
         count = resp.parts_count
+
         if count.nil? || count <= 1
           if resp.content_length <= MIN_CHUNK_SIZE
-            single_request
+            single_request(opts)
           else
-            multithreaded_get_by_ranges(resp.content_length)
+            resolve_temp_path(opts)
+            multithreaded_get_by_ranges(resp.content_length, resp.etag, opts)
           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(head_opts(opts[:params])) # partNumber is an option
           if resp.content_length <= MIN_CHUNK_SIZE
-            single_request
+            single_request(opts)
           else
-            compute_mode(resp.content_length, count)
+            compute_mode(resp.content_length, count, resp.etag, opts)
           end
         end
       end
 
-      def compute_mode(file_size, count)
-        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(file_size)
-        else
-          multithreaded_get_by_parts(count, file_size)
+      def multithreaded_get_by_parts(total_parts, file_size, etag, opts)
+        parts = (1..total_parts).map do |part|
+          params = get_opts(opts[:params].merge(part_number: part, if_match: etag))
+          Part.new(part_number: part, params: params)
         end
+        download_with_executor(PartList.new(parts), file_size, opts)
       end
 
-      def construct_chunks(file_size)
+      def multithreaded_get_by_ranges(file_size, etag, opts)
         offset = 0
-        default_chunk_size = compute_chunk(file_size)
+        default_chunk_size = compute_chunk(opts[:chunk_size], 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
-          chunks << "bytes=#{offset}-#{progress - 1}"
+          params = get_opts(opts[: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
-        chunks
+        download_with_executor(PartList.new(chunks), file_size, opts)
       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
+      def range_request(opts)
+        resp = @client.head_object(head_opts(opts[:params]))
+        resolve_temp_path(opts)
+        multithreaded_get_by_ranges(resp.content_length, resp.etag, opts)
       end
 
-      def batches(chunks, mode)
-        chunks = (1..chunks) if mode.eql? 'part_number'
-        chunks.each_slice(@thread_count).to_a
+      def resolve_temp_path(opts)
+        return if [File, Tempfile].include?(opts[:destination].class)
+
+        opts[:temp_path] ||= "#{opts[:destination]}.s3tmp.#{SecureRandom.alphanumeric(8)}"
       end
 
-      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)
+      def single_request(opts)
+        params = get_opts(opts[:params]).merge(response_target: opts[:destination])
+        params[:on_chunk_received] = single_part_progress(opts) if opts[:progress_callback]
+        resp = @client.get_object(params)
+        return resp unless opts[:on_checksum_validated]
+
+        opts[:on_checksum_validated].call(resp.checksum_validated, resp) if resp.checksum_validated
+        resp
       end
 
-      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))
+      def single_part_progress(opts)
+        proc do |_chunk, bytes_read, total_size|
+          opts[:progress_callback].call([bytes_read], [total_size], total_size)
         end
-        download_in_threads(PartList.new(parts), total_size)
       end
 
-      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
+      def update_progress(progress, part)
+        return unless progress.progress_callback
+
+        part.params[:on_chunk_received] =
+          proc do |_chunk, bytes, total|
+            progress.call(part.part_number, bytes, total)
           end
-          threads << thread
-        end
-        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 execute_checksum_callback(resp, opts)
+        return unless opts[:on_checksum_validated] && resp.checksum_validated
+
+        opts[:on_checksum_validated].call(resp.checksum_validated, resp)
       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)
+      def validate_destination!(destination)
+        valid_types = [String, Pathname, File, Tempfile]
+        return if valid_types.include?(destination.class)
 
-        return resp unless @on_checksum_validated
+        raise ArgumentError, "Invalid destination, expected #{valid_types.join(', ')} but got: #{destination.class}"
+      end
 
-        if resp.checksum_validated
-          @on_checksum_validated.call(resp.checksum_validated, resp)
+      def validate_opts!(opts)
+        if opts[:on_checksum_validated] && !opts[:on_checksum_validated].respond_to?(:call)
+          raise ArgumentError, ':on_checksum_validated must be callable'
         end
 
-        resp
-      end
+        valid_modes = %w[auto get_range single_request]
+        unless valid_modes.include?(opts[:mode])
+          msg = "Invalid mode #{opts[:mode]} provided, :mode should be single_request, get_range or auto"
+          raise ArgumentError, msg
+        end
 
-      def single_part_progress
-        proc do |_chunk, bytes_read, total_size|
-          @progress_callback.call([bytes_read], [total_size], total_size)
+        if opts[:mode] == 'get_range' && opts[:chunk_size].nil?
+          raise ArgumentError, 'In get_range mode, :chunk_size must be provided'
         end
+
+        if opts[:chunk_size] && opts[:chunk_size] <= 0
+          raise ArgumentError, ':chunk_size must be positive'
+        end
+      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, opts)
+        path = opts[:temp_path] || opts[:destination]
+        File.write(path, body.read, range.split('-').first.to_i)
+      end
+
+      # @api private
       class Part < Struct.new(:part_number, :size, :params)
         include Aws::Structure
       end
@@ -251,7 +295,7 @@ module Aws
       end
 
       # @api private
-      class  MultipartProgress
+      class MultipartProgress
         def initialize(parts, total_size, progress_callback)
           @bytes_received = Array.new(parts.size, 0)
           @part_sizes = parts.map(&:size)
@@ -259,6 +303,8 @@ module Aws
           @progress_callback = progress_callback
         end
 
+        attr_reader :progress_callback
+
         def call(part_number, bytes_received, total)
           # part numbers start at 1
           @bytes_received[part_number - 1] = bytes_received

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

@@ -7,23 +7,21 @@ 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
       # @option options [Integer] :multipart_threshold (104857600)
       def initialize(options = {})
-        @options = options
         @client = options[:client] || Client.new
-        @multipart_threshold = options[:multipart_threshold] ||
-                               ONE_HUNDRED_MEGABYTES
+        @executor = options[:executor]
+        @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.
@@ -38,11 +36,9 @@ module Aws
       # @return [void]
       def upload(source, options = {})
         Aws::Plugins::UserAgent.metric('S3_TRANSFER') do
-          if File.size(source) >= multipart_threshold
-            MultipartFileUploader.new(@options).upload(source, options)
+          if File.size(source) >= @multipart_threshold
+            MultipartFileUploader.new(client: @client, executor: @executor).upload(source, options)
           else
-            # remove multipart parameters not supported by put_object
-            options.delete(:thread_count)
             put_object(source, options)
           end
         end
@@ -50,9 +46,9 @@ module Aws
 
       private
 
-      def open_file(source)
-        if String === source || Pathname === source
-          File.open(source, 'rb') { |file| yield(file) }
+      def open_file(source, &block)
+        if source.is_a?(String) || source.is_a?(Pathname)
+          File.open(source, 'rb', &block)
         else
           yield(source)
         end

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

@@ -3,7 +3,8 @@
 require 'set'
 require 'time'
 require 'openssl'
-require 'cgi'
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 require 'aws-sdk-core/query'
 
 module Aws

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