aws-sdk-s3 1.128.0 → 1.199.1

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,5 +177,18 @@ 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
+
+# Load customizations if they exist
+require 'aws-sdk-s3/customizations/errors'

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Aws
+  module S3
+    # @api private
+    class ExpressCredentials
+      include CredentialProvider
+      include RefreshingCredentials
+
+      SYNC_EXPIRATION_LENGTH = 60 # 1 minute
+      ASYNC_EXPIRATION_LENGTH = 120 # 2 minutes
+
+      def initialize(options = {})
+        @client = options[:client]
+        @create_session_params = {}
+        options.each_pair do |key, value|
+          if self.class.create_session_options.include?(key)
+            @create_session_params[key] = value
+          end
+        end
+        @async_refresh = true
+        super
+      end
+
+      # @return [S3::Client]
+      attr_reader :client
+
+      private
+
+      def refresh
+        c = @client.create_session(@create_session_params).credentials
+        @credentials = Credentials.new(
+          c.access_key_id,
+          c.secret_access_key,
+          c.session_token
+        )
+        @expiration = c.expiration
+      end
+
+      class << self
+
+        # @api private
+        def create_session_options
+          @cso ||= begin
+            input = S3::Client.api.operation(:create_session).input
+            Set.new(input.shape.member_names)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    # @api private
+    def self.express_credentials_cache
+      @express_credentials_cache ||= LRUCache.new(max_entries: 100)
+    end
+
+    # Returns Credentials class for S3 Express. Accepts CreateSession
+    # params as options. See {Client#create_session} for details.
+    class ExpressCredentialsProvider
+      # @param [Hash] options
+      # @option options [Client] :client The S3 client used to create the
+      #  session.
+      # @option options [String] :session_mode (see: {Client#create_session})
+      # @option options [Boolean] :caching (true) When true, credentials will
+      #  be cached.
+      # @option options [Callable] :before_refresh Proc called before
+      #   credentials are refreshed.
+      def initialize(options = {})
+        @client = options.delete(:client)
+        @caching = options.delete(:caching) != false
+        @options = options
+        return unless @caching
+
+        @cache = Aws::S3.express_credentials_cache
+      end
+
+      def express_credentials_for(bucket)
+        if @caching
+          cached_credentials_for(bucket)
+        else
+          new_credentials_for(bucket)
+        end
+      end
+
+      attr_accessor :client
+
+      private
+
+      def cached_credentials_for(bucket)
+        if @cache.key?(bucket)
+          @cache[bucket]
+        else
+          @cache[bucket] = new_credentials_for(bucket)
+        end
+      end
+
+      def new_credentials_for(bucket)
+        ExpressCredentials.new(
+          bucket: bucket,
+          client: @client,
+          **@options
+        )
+      end
+    end
+  end
+end

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
@@ -22,129 +20,218 @@ module Aws
       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]
-
-        Aws::Plugins::UserAgent.feature('s3-transfer') do
+        valid_types = [String, Pathname, File, Tempfile]
+        unless valid_types.include?(destination.class)
+          raise ArgumentError, "Invalid destination, expected #{valid_types.join(', ')} but got: #{destination.class}"
+        end
+
+        @destination = destination
+        @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
           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))
-            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, @destination) if @temp_path
+      ensure
+        File.delete(@temp_path) if @temp_path && File.exist?(@temp_path)
       end
 
       private
 
+      def validate!
+        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
           else
-            multithreaded_get_by_ranges(construct_chunks(resp.content_length))
+            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
-            compute_mode(resp.content_length, count)
+            compute_mode(resp.content_length, count, resp.etag)
           end
         end
       end
 
-      def compute_mode(file_size, count)
+      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(construct_chunks(file_size))
+          multithreaded_get_by_ranges(file_size, etag)
         else
-          multithreaded_get_by_parts(count)
+          multithreaded_get_by_parts(count, file_size, etag)
         end
       end
 
-      def construct_chunks(file_size)
+      def compute_chunk(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 multithreaded_get_by_ranges(file_size, etag)
         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
-          chunks << "bytes=#{offset}-#{progress - 1}"
+          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
-        chunks
+        download_in_threads(PartList.new(chunks), file_size)
       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
+      def multithreaded_get_by_parts(n_parts, total_size, etag)
+        parts = (1..n_parts).map do |part|
+          Part.new(part_number: part, params: @params.merge(part_number: part, if_match: etag))
         end
+        download_in_threads(PartList.new(parts), total_size)
       end
 
-      def batches(chunks, mode)
-        chunks = (1..chunks) if mode.eql? 'part_number'
-        chunks.each_slice(@thread_count).to_a
+      def download_in_threads(pending, total_size)
+        threads = []
+        progress = MultipartProgress.new(pending, total_size, @progress_callback) if @progress_callback
+        unless [File, Tempfile].include?(@destination.class)
+          @temp_path = "#{@destination}.s3tmp.#{SecureRandom.alphanumeric(8)}"
+        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)
+                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 StandardError => e
+              pending.clear! # keep other threads from downloading other parts
+              raise e
+            end
+          end
+          threads << thread
+        end
+        threads.map(&:value).compact
       end
 
-      def multithreaded_get_by_ranges(chunks)
-        thread_batches(chunks, 'range')
+      def extract_range(value)
+        value.match(%r{bytes (?<range>\d+-\d+)/\d+})[:range]
       end
 
-      def multithreaded_get_by_parts(parts)
-        thread_batches(parts, 'part_number')
+      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 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)
-            end
-          end
-          threads.each(&:join)
+      def write(body, range)
+        path = @temp_path || @destination
+        File.write(path, body.read, range.split('-').first.to_i)
+      end
+
+      def single_request
+        params = @params.merge(response_target: @destination)
+        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
+
+      def single_part_progress
+        proc do |_chunk, bytes_read, total_size|
+          @progress_callback.call([bytes_read], [total_size], total_size)
         end
       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)
+      # @api private
+      class Part < Struct.new(:part_number, :size, :params)
+        include Aws::Structure
       end
 
-      def single_request
-        @client.get_object(
-          @params.merge(response_target: @path)
-        )
+      # @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

@@ -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.
@@ -37,7 +35,7 @@ module Aws
       #   objects smaller than the multipart threshold.
       # @return [void]
       def upload(source, options = {})
-        Aws::Plugins::UserAgent.feature('s3-transfer') do
+        Aws::Plugins::UserAgent.metric('S3_TRANSFER') do
           if File.size(source) >= multipart_threshold
             MultipartFileUploader.new(@options).upload(source, options)
           else

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