aws-sdk-s3 1.182.0 → 1.198.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(
@@ -445,6 +469,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(
@@ -1162,6 +1198,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 +1232,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 +1302,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 +1324,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
@@ -1294,6 +1370,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
@@ -1416,10 +1494,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,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,18 +20,18 @@ 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]
-        @on_checksum_validated = options[:on_checksum_validated]
-        @progress_callback = options[:progress_callback]
-
+        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
@@ -41,88 +39,65 @@ module Aws
           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
+            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!
-        if @on_checksum_validated && !@on_checksum_validated.respond_to?(:call)
-          raise ArgumentError, 'on_checksum_validated must be callable'
-        end
+        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(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(file_size)
+          multithreaded_get_by_ranges(file_size, etag)
         else
-          multithreaded_get_by_parts(count, file_size)
-        end
-      end
-
-      def construct_chunks(file_size)
-        offset = 0
-        default_chunk_size = compute_chunk(file_size)
-        chunks = []
-        while offset < file_size
-          progress = offset + default_chunk_size
-          progress = file_size if progress > file_size
-          chunks << "bytes=#{offset}-#{progress - 1}"
-          offset = progress
+          multithreaded_get_by_parts(count, file_size, etag)
         end
-        chunks
       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
-      end
+        raise ArgumentError, ":chunk_size shouldn't exceed total file size." if @chunk_size && @chunk_size > file_size
 
-      def batches(chunks, mode)
-        chunks = (1..chunks) if mode.eql? 'part_number'
-        chunks.each_slice(@thread_count).to_a
+        @chunk_size || [(file_size.to_f / MAX_PARTS).ceil, MIN_CHUNK_SIZE].max.to_i
       end
 
-      def multithreaded_get_by_ranges(file_size)
+      def multithreaded_get_by_ranges(file_size, etag)
         offset = 0
         default_chunk_size = compute_chunk(file_size)
         chunks = []
@@ -130,21 +105,17 @@ module Aws
         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)
-          )
+          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
         download_in_threads(PartList.new(chunks), file_size)
       end
 
-      def multithreaded_get_by_parts(n_parts, total_size)
+      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))
+          Part.new(part_number: part, params: @params.merge(part_number: part, if_match: etag))
         end
         download_in_threads(PartList.new(parts), total_size)
       end
@@ -152,10 +123,13 @@ module Aws
       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
+              while (part = pending.shift)
                 if progress
                   part.params[:on_chunk_received] =
                     proc do |_chunk, bytes, total|
@@ -163,16 +137,17 @@ module Aws
                     end
                 end
                 resp = @client.get_object(part.params)
-                write(resp)
+                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 => error
-              # keep other threads from downloading other parts
-              pending.clear!
-              raise error
+            rescue StandardError => e
+              pending.clear! # keep other threads from downloading other parts
+              raise e
             end
           end
           threads << thread
@@ -180,21 +155,28 @@ module Aws
         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 extract_range(value)
+        value.match(%r{bytes (?<range>\d+-\d+)/\d+})[:range]
+      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)
+        path = @temp_path || @destination
+        File.write(path, body.read, range.split('-').first.to_i)
       end
 
       def single_request
-        params = @params.merge(response_target: @path)
+        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
 
@@ -204,6 +186,7 @@ module Aws
         end
       end
 
+      # @api private
       class Part < Struct.new(:part_number, :size, :params)
         include Aws::Structure
       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.

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