aws-sdk-s3 1.176.1 → 1.208.0

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

@@ -63,6 +63,18 @@ module Aws::S3
       end
     end
 
+    class CreateBucketMetadataConfiguration
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          use_s3_express_control_endpoint: true,
+        )
+      end
+    end
+
     class CreateBucketMetadataTableConfiguration
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -183,6 +195,18 @@ module Aws::S3
       end
     end
 
+    class DeleteBucketMetadataConfiguration
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          use_s3_express_control_endpoint: true,
+        )
+      end
+    end
+
     class DeleteBucketMetadataTableConfiguration
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -313,6 +337,17 @@ module Aws::S3
       end
     end
 
+    class GetBucketAbac
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+        )
+      end
+    end
+
     class GetBucketAccelerateConfiguration
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -445,6 +480,18 @@ module Aws::S3
       end
     end
 
+    class GetBucketMetadataConfiguration
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          use_s3_express_control_endpoint: true,
+        )
+      end
+    end
+
     class GetBucketMetadataTableConfiguration
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -842,6 +889,17 @@ module Aws::S3
       end
     end
 
+    class PutBucketAbac
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+        )
+      end
+    end
+
     class PutBucketAccelerateConfiguration
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -1162,6 +1220,18 @@ module Aws::S3
       end
     end
 
+    class RenameObject
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          key: context.params[:key],
+        )
+      end
+    end
+
     class RestoreObject
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -1184,6 +1254,30 @@ module Aws::S3
       end
     end
 
+    class UpdateBucketMetadataInventoryTableConfiguration
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          use_s3_express_control_endpoint: true,
+        )
+      end
+    end
+
+    class UpdateBucketMetadataJournalTableConfiguration
+      def self.build(context)
+        Aws::S3::EndpointParameters.create(
+          context.config,
+          bucket: context.params[:bucket],
+          use_dual_stack: context[:use_dualstack_endpoint],
+          accelerate: context[:use_accelerate_endpoint],
+          use_s3_express_control_endpoint: true,
+        )
+      end
+    end
+
     class UploadPart
       def self.build(context)
         Aws::S3::EndpointParameters.create(
@@ -1230,6 +1324,8 @@ module Aws::S3
         CopyObject.build(context)
       when :create_bucket
         CreateBucket.build(context)
+      when :create_bucket_metadata_configuration
+        CreateBucketMetadataConfiguration.build(context)
       when :create_bucket_metadata_table_configuration
         CreateBucketMetadataTableConfiguration.build(context)
       when :create_multipart_upload
@@ -1250,6 +1346,8 @@ module Aws::S3
         DeleteBucketInventoryConfiguration.build(context)
       when :delete_bucket_lifecycle
         DeleteBucketLifecycle.build(context)
+      when :delete_bucket_metadata_configuration
+        DeleteBucketMetadataConfiguration.build(context)
       when :delete_bucket_metadata_table_configuration
         DeleteBucketMetadataTableConfiguration.build(context)
       when :delete_bucket_metrics_configuration
@@ -1272,6 +1370,8 @@ module Aws::S3
         DeleteObjects.build(context)
       when :delete_public_access_block
         DeletePublicAccessBlock.build(context)
+      when :get_bucket_abac
+        GetBucketAbac.build(context)
       when :get_bucket_accelerate_configuration
         GetBucketAccelerateConfiguration.build(context)
       when :get_bucket_acl
@@ -1294,6 +1394,8 @@ module Aws::S3
         GetBucketLocation.build(context)
       when :get_bucket_logging
         GetBucketLogging.build(context)
+      when :get_bucket_metadata_configuration
+        GetBucketMetadataConfiguration.build(context)
       when :get_bucket_metadata_table_configuration
         GetBucketMetadataTableConfiguration.build(context)
       when :get_bucket_metrics_configuration
@@ -1362,6 +1464,8 @@ module Aws::S3
         ListObjectsV2.build(context)
       when :list_parts
         ListParts.build(context)
+      when :put_bucket_abac
+        PutBucketAbac.build(context)
       when :put_bucket_accelerate_configuration
         PutBucketAccelerateConfiguration.build(context)
       when :put_bucket_acl
@@ -1416,10 +1520,16 @@ module Aws::S3
         PutObjectTagging.build(context)
       when :put_public_access_block
         PutPublicAccessBlock.build(context)
+      when :rename_object
+        RenameObject.build(context)
       when :restore_object
         RestoreObject.build(context)
       when :select_object_content
         SelectObjectContent.build(context)
+      when :update_bucket_metadata_inventory_table_configuration
+        UpdateBucketMetadataInventoryTableConfiguration.build(context)
+      when :update_bucket_metadata_journal_table_configuration
+        UpdateBucketMetadataJournalTableConfiguration.build(context)
       when :upload_part
         UploadPart.build(context)
       when :upload_part_copy

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

@@ -30,6 +30,7 @@ module Aws::S3
   # * {BucketAlreadyExists}
   # * {BucketAlreadyOwnedByYou}
   # * {EncryptionTypeMismatch}
+  # * {IdempotencyParameterMismatch}
   # * {InvalidObjectState}
   # * {InvalidRequest}
   # * {InvalidWriteOffset}
@@ -76,6 +77,16 @@ module Aws::S3
       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

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