aws-sdk-s3 1.53.0 → 1.146.0

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

@@ -1,14 +1,136 @@
+# frozen_string_literal: true
+
 # WARNING ABOUT GENERATED CODE
 #
 # This file is generated. See the contributing guide for more information:
-# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
 #
 # WARNING ABOUT GENERATED CODE
 
 module Aws::S3
+
+  # When S3 returns an error response, the Ruby SDK constructs and raises an error.
+  # These errors all extend Aws::S3::Errors::ServiceError < {Aws::Errors::ServiceError}
+  #
+  # You can rescue all S3 errors using ServiceError:
+  #
+  #     begin
+  #       # do stuff
+  #     rescue Aws::S3::Errors::ServiceError
+  #       # rescues all S3 API errors
+  #     end
+  #
+  #
+  # ## Request Context
+  # ServiceError objects have a {Aws::Errors::ServiceError#context #context} method that returns
+  # information about the request that generated the error.
+  # See {Seahorse::Client::RequestContext} for more information.
+  #
+  # ## Error Classes
+  # * {BucketAlreadyExists}
+  # * {BucketAlreadyOwnedByYou}
+  # * {InvalidObjectState}
+  # * {NoSuchBucket}
+  # * {NoSuchKey}
+  # * {NoSuchUpload}
+  # * {ObjectAlreadyInActiveTierError}
+  # * {ObjectNotInActiveTierError}
+  #
+  # Additionally, error classes are dynamically generated for service errors based on the error code
+  # if they are not defined above.
   module Errors
 
     extend Aws::Errors::DynamicErrors
 
+    class BucketAlreadyExists < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::BucketAlreadyExists] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class BucketAlreadyOwnedByYou < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::BucketAlreadyOwnedByYou] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class InvalidObjectState < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::InvalidObjectState] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+
+      # @return [String]
+      def storage_class
+        @data[:storage_class]
+      end
+
+      # @return [String]
+      def access_tier
+        @data[:access_tier]
+      end
+    end
+
+    class NoSuchBucket < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::NoSuchBucket] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class NoSuchKey < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::NoSuchKey] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class NoSuchUpload < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::NoSuchUpload] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class ObjectAlreadyInActiveTierError < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::ObjectAlreadyInActiveTierError] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
+    class ObjectNotInActiveTierError < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::S3::Types::ObjectNotInActiveTierError] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+    end
+
   end
 end

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 # WARNING ABOUT GENERATED CODE
 #
 # This file is generated. See the contributing guide for more information:
-# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
 #
 # WARNING ABOUT GENERATED CODE
 
@@ -41,6 +43,10 @@ module Aws::S3
         @event_emitter.on(:initial_response, block) if block_given?
       end
 
+      def on_unknown_event(&block)
+        @event_emitter.on(:unknown_event, block) if block_given?
+      end
+
       def on_event(&block)
         on_records_event(&block)
         on_stats_event(&block)
@@ -49,6 +55,7 @@ module Aws::S3
         on_end_event(&block)
         on_error_event(&block)
         on_initial_response_event(&block)
+        on_unknown_event(&block)
       end
 
       # @api private

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_cache.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    # @api private
+    class ExpressCredentialsCache
+      def initialize
+        @credentials = {}
+        @mutex = Mutex.new
+      end
+
+      def [](bucket_name)
+        @mutex.synchronize { @credentials[bucket_name] }
+      end
+
+      def []=(bucket_name, credential_provider)
+        @mutex.synchronize do
+          @credentials[bucket_name] = credential_provider
+        end
+      end
+
+      def clear
+        @mutex.synchronize { @credentials = {} }
+      end
+    end
+
+    # @api private
+    EXPRESS_CREDENTIALS_CACHE = ExpressCredentialsCache.new
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    # 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 [Callable] :before_refresh Proc called before
+      #   credentials are refreshed.
+      def initialize(options = {})
+        @client = options.delete(:client)
+        @options = options
+        @cache = EXPRESS_CREDENTIALS_CACHE
+      end
+
+      def express_credentials_for(bucket)
+        @cache[bucket] || new_credentials_for(bucket)
+      end
+
+      attr_accessor :client
+
+      private
+
+      def new_credentials_for(bucket)
+        @cache[bucket] = ExpressCredentials.new(
+          bucket: bucket,
+          client: @client,
+          **@options
+        )
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'thread'
 require 'set'
@@ -21,7 +23,7 @@ module Aws
 
       def download(destination, options = {})
         @path = destination
-        @mode = options[:mode] || "auto"
+        @mode = options[:mode] || 'auto'
         @thread_count = options[:thread_count] || THREAD_COUNT
         @chunk_size = options[:chunk_size]
         @params = {
@@ -30,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
 
@@ -70,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
 
@@ -80,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
@@ -92,7 +124,9 @@ module Aws
         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
+          @chunk_size || [
+            (file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE
+          ].max.to_i
         end
       end
 
@@ -101,39 +135,137 @@ 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)
+          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}
-        IO.write(@path, resp.body.read, head)
+        range, _ = resp.content_range.split(' ').last.split('/')
+        head, _ = range.split('-').map {|s| s.to_i}
+        File.write(@path, resp.body.read, head)
       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_part.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Aws
@@ -5,34 +7,44 @@ 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 (15728640)
+      # @option options [Integer] :multipart_threshold (104857600)
       def initialize(options = {})
         @options = options
         @client = options[:client] || Client.new
         @multipart_threshold = options[:multipart_threshold] ||
-                               FIFTEEN_MEGABYTES
+                               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 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.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
 
@@ -47,11 +59,19 @@ module Aws
       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