aws-sdk-s3 1.220.0 → 1.232.2

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

@@ -1,20 +1,22 @@
 # frozen_string_literal: true
 
-require 'thread'
-require "cgi/escape"
-require "cgi/util" if RUBY_VERSION < "3.5"
+require 'cgi/escape'
+require 'cgi/util' if RUBY_VERSION < '3.5'
+require 'set'
 
 module Aws
   module S3
     # @api private
-    class ObjectMultipartCopier
-
-      FIVE_MB = 5 * 1024 * 1024 # 5MB
-
-      FILE_TOO_SMALL = "unable to multipart copy files smaller than 5MB"
-
+    class ObjectMultipartCopier # rubocop:disable Metrics/ClassLength
+      MIN_PART_SIZE = 5 * 1024 * 1024 # 5MB
       MAX_PARTS = 10_000
 
+      API_OPTIONS = {
+        create_multipart_upload: Set.new(Client.api.operation(:create_multipart_upload).input.shape.member_names),
+        upload_part_copy: Set.new(Client.api.operation(:upload_part_copy).input.shape.member_names),
+        complete_multipart_upload: Set.new(Client.api.operation(:complete_multipart_upload).input.shape.member_names)
+      }.freeze
+
       # @option options [Client] :client
       # @option options [Integer] :min_part_size (52428800)
       #   Size of copied parts. Defaults to 50MB.
@@ -29,29 +31,115 @@ module Aws
       def initialize(options = {})
         @use_source_parts = options.delete(:use_source_parts) || false
         @thread_count = options.delete(:thread_count) || 10
-        @min_part_size = options.delete(:min_part_size) || (FIVE_MB * 10)
+        @min_part_size = options.delete(:min_part_size) || (MIN_PART_SIZE * 10)
         @client = options[:client] || Client.new
+        @source_client = nil
+        @source = nil
+        @source_etag = nil
+        @source_parts_count = nil
+        @first_part_size = nil
       end
 
       # @return [Client]
       attr_reader :client
 
       # @option (see S3::Client#copy_object)
-      def copy(options = {})
-        metadata = source_metadata(options)
+      def copy(options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        @source_client = options[:copy_source_client] || @client
+        @source = resolve_source(options[:copy_source])
+        metadata = resolve_metadata(options)
         size = metadata[:content_length]
-        options[:upload_id] = initiate_upload(metadata.merge(options))
+        @source_etag = metadata[:etag]
+        @source[:version_id] ||= metadata[:version_id]
+        resolve_source_parts
+        tag_set = resolve_tags(options)
+        annotations = resolve_annotations(options)
+
+        create_opts = resolve_create_opts(metadata, options)
+        options[:upload_id] = initiate_upload(create_opts)
+
         begin
           parts = copy_parts(size, default_part_size(size), options)
-          complete_upload(parts, options)
-        rescue => error
+          resp = complete_upload(parts, options)
+        rescue StandardError => e
           abort_upload(options)
-          raise error
+          raise e
         end
+
+        put_tags(tag_set, resp, options) if tag_set
+        put_annotations(annotations, resp, options) if annotations&.any?
+        resp
       end
 
       private
 
+      def resolve_source(copy_source)
+        bucket, remaining = copy_source.split('/', 2)
+        key, version_id = remaining.split('?versionId=', 2)
+        result = { bucket: bucket, key: CGI.unescape(key) }
+        result[:version_id] = version_id if version_id
+        result
+      end
+
+      def resolve_metadata(options)
+        return options.slice(:content_length) if options[:content_length]
+
+        resp = @source_client.head_object(@source).to_h
+        resp.delete(:server_side_encryption)
+        resp.delete(:ssekms_key_id)
+        resp
+      end
+
+      def resolve_source_parts
+        return unless @use_source_parts
+
+        resp = @source_client.head_object(@source.merge(part_number: 1))
+        @source_parts_count = resp.parts_count
+        @first_part_size = resp.content_length if @source_parts_count
+      end
+
+      def resolve_create_opts(metadata, options)
+        return options if options[:metadata_directive] == 'REPLACE'
+
+        create_opts = metadata.merge(options)
+        create_opts.delete(:tagging) if options[:tags_directive]
+        create_opts
+      end
+
+      def resolve_tags(options) # rubocop:disable Metrics/MethodLength
+        return unless options[:tags_directive]
+
+        case options[:tags_directive]
+        when 'COPY'
+          resp = @source_client.get_object_tagging(@source)
+          resp.tag_set
+        when 'REPLACE'
+          tagging = options[:tagging]
+          return if tagging.nil? || tagging.empty?
+
+          tagging.split('&').map do |pair|
+            k, v = pair.split('=', 2)
+            { key: CGI.unescape(k), value: CGI.unescape(v) }
+          end
+        end
+      end
+
+      def resolve_annotations(options) # rubocop:disable Metrics/MethodLength
+        return unless options[:annotations_directive] == 'COPY'
+
+        list_resp = @source_client.list_object_annotations(@source)
+        return if list_resp.annotations.empty?
+
+        list_resp.annotations.map do |annotation|
+          {
+            name: annotation.annotation_name,
+            payload: @source_client.get_object_annotation(
+              @source.merge(annotation_name: annotation.annotation_name)
+            ).annotation_payload
+          }
+        end
+      end
+
       def initiate_upload(options)
         options = options_for(:create_multipart_upload, options)
         @client.create_multipart_upload(options).upload_id
@@ -63,28 +151,30 @@ module Aws
         @thread_count.times do
           threads << copy_part_thread(queue)
         end
-        threads.map(&:value).flatten.sort_by{ |part| part[:part_number] }
+        threads.map(&:value).flatten.sort_by { |part| part[:part_number] }
       end
 
-      def copy_part_thread(queue)
+      def copy_part_thread(queue) # rubocop:disable Metrics/MethodLength
         Thread.new do
-          begin
+          begin # rubocop:disable Style/RedundantBegin
             completed = []
-            while part = queue.shift
+            while (part = queue.shift)
               completed << copy_part(part)
             end
             completed
-          rescue => error
+          rescue StandardError => e
             queue.clear!
-            raise error
+            raise e
           end
         end
       end
 
       def copy_part(part)
-        @client.upload_part_copy(part).copy_part_result.to_h.merge({
-          part_number: part[:part_number]
-        }).tap { |result| result.delete(:last_modified) }
+        @client.upload_part_copy(part)
+               .copy_part_result
+               .to_h
+               .merge({ part_number: part[:part_number] })
+               .tap { |result| result.delete(:last_modified) }
       end
 
       def complete_upload(parts, options)
@@ -94,100 +184,104 @@ module Aws
       end
 
       def abort_upload(options)
-        @client.abort_multipart_upload({
-          bucket: options[:bucket],
-          key: options[:key],
-          upload_id: options[:upload_id],
-        })
+        @client.abort_multipart_upload(
+          {
+            bucket: options[:bucket],
+            key: options[:key],
+            upload_id: options[:upload_id]
+          }
+        )
       end
 
-      def compute_parts(size, default_part_size, options)
+      def compute_parts(size, default_part_size, options) # rubocop:disable Metrics/MethodLength
         part_number = 1
         offset = 0
         parts = []
         options = options_for(:upload_part_copy, options)
+        options[:copy_source_if_match] = @source_etag if @source_etag
         while offset < size
           part_size = calculate_part_size(part_number, default_part_size, options)
-          parts << options.merge({
-            part_number: part_number,
-            copy_source_range: byte_range(offset, part_size, size),
-          })
+          parts << options.merge({ part_number: part_number, copy_source_range: byte_range(offset, part_size, size) })
           part_number += 1
           offset += part_size
         end
         parts
       end
 
-      def byte_range(offset, part_size, size)
-        if offset + part_size < size
-          "bytes=#{offset}-#{offset + part_size - 1}"
-        else
-          "bytes=#{offset}-#{size - 1}"
-        end
-      end
-
-      def calculate_part_size(part_number, default_part_size, options)
-        if @use_source_parts && source_has_parts(options)
-          source_metadata(options.merge({ part_number: part_number }))[:content_length]
+      def calculate_part_size(part_number, default_part_size, _options)
+        if @source_parts_count
+          resolve_part_size(part_number)
         else
           default_part_size
         end
       end
 
-      def source_has_parts(options)
-        @source_has_parts ||= source_metadata(options.merge({ part_number: 1 }))[:parts_count]
-      end
-
-      def source_metadata(options)
-        return options.slice(:content_length) if options[:content_length]
+      def resolve_part_size(part_number)
+        return @first_part_size if part_number == 1 && @first_part_size
 
-        client = options[:copy_source_client] || @client
+        @source_client.head_object(@source.merge(part_number: part_number)).content_length
+      end
 
-        if vid_match = options[:copy_source].match(/([^\/]+?)\/(.+)\?versionId=(.+)/)
-          bucket, key, version_id = vid_match[1,3]
+      def byte_range(offset, part_size, size)
+        if offset + part_size < size
+          "bytes=#{offset}-#{offset + part_size - 1}"
         else
-          bucket, key = options[:copy_source].match(/([^\/]+?)\/(.+)/)[1,2]
+          "bytes=#{offset}-#{size - 1}"
         end
+      end
 
-        head_opts = { bucket: bucket, key: CGI.unescape(key) }.tap { |opts|
-          opts[:version_id]  = version_id if version_id
-          opts[:part_number] = options[:part_number] if options[:part_number]
-        }
+      def default_part_size(source_size)
+        raise ArgumentError, 'unable to multipart copy files smaller than 5MB' if source_size < MIN_PART_SIZE
 
-        client.head_object(head_opts).to_h.tap { |head|
-          head.delete(:server_side_encryption)
-          head.delete(:ssekms_key_id)
-        }
+        [(source_size.to_f / MAX_PARTS).ceil, @min_part_size].max.to_i
       end
 
-      def default_part_size(source_size)
-        if source_size < FIVE_MB
-          raise ArgumentError, FILE_TOO_SMALL
-        else
-          [(source_size.to_f / MAX_PARTS).ceil, @min_part_size].max.to_i
+      def put_tags(tags, resp, options)
+        @client.put_object_tagging(
+          bucket: options[:bucket],
+          key: options[:key],
+          tagging: { tag_set: tags },
+          version_id: resp.version_id
+        )
+      rescue StandardError => e
+        raise StandardError,
+              'Object data copied successfully. ' \
+              "Failed to copy tags: #{e.message}"
+      end
+
+      def put_annotations(annotations, response, options) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        succeeded = []
+        failed = []
+
+        annotations.each do |annotation|
+          @client.put_object_annotation(
+            bucket: options[:bucket],
+            key: options[:key],
+            version_id: response.version_id,
+            object_if_match: response.etag,
+            annotation_name: annotation[:name],
+            annotation_payload: annotation[:payload]
+          )
+          succeeded << annotation[:name]
+        rescue StandardError => e
+          failed << { key: annotation[:name], error: e }
         end
+        return if failed.empty?
+
+        raise StandardError,
+              'Object data copied successfully. Failed to copy annotations: ' \
+              "#{failed.map { |f| "#{f[:key]} (#{f[:error].message})" }.join(', ')}. " \
+              "Succeeded: #{succeeded.join(', ')}"
       end
 
       def options_for(operation_name, options)
-        API_OPTIONS[operation_name].inject({}) do |hash, opt_name|
+        API_OPTIONS[operation_name].each_with_object({}) do |opt_name, hash|
           hash[opt_name] = options[opt_name] if options.key?(opt_name)
-          hash
         end
       end
 
-      # @api private
-      def self.options_for(shape_name)
-        Client.api.metadata['shapes'][shape_name].member_names
-      end
-
-      API_OPTIONS = {
-        create_multipart_upload: Types::CreateMultipartUploadRequest.members,
-        upload_part_copy: Types::UploadPartCopyRequest.members,
-        complete_multipart_upload: Types::CompleteMultipartUploadRequest.members,
-      }
-
+      # A thread-safe work queue of part definitions for a multipart copy.
       class PartQueue
-
         def initialize(parts = [])
           @parts = parts
           @mutex = Mutex.new
@@ -200,7 +294,6 @@ module Aws
         def clear!
           @mutex.synchronize { @parts.clear }
         end
-
       end
     end
   end

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

@@ -361,8 +361,9 @@ module Aws::S3
     #     },
     #     metadata_directive: "COPY", # accepts COPY, REPLACE
     #     tagging_directive: "COPY", # accepts COPY, REPLACE
-    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:kms, aws:kms:dsse
-    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP
+    #     annotation_directive: "COPY", # accepts COPY, EXCLUDE
+    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:backup, aws:kms, aws:kms:dsse
+    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP, AWS_BACKUP_WARM, AWS_BACKUP_LOW_COST_WARM
     #     website_redirect_location: "WebsiteRedirectLocation",
     #     sse_customer_algorithm: "SSECustomerAlgorithm",
     #     sse_customer_key: "SSECustomerKey",
@@ -378,6 +379,9 @@ module Aws::S3
     #     object_lock_mode: "GOVERNANCE", # accepts GOVERNANCE, COMPLIANCE
     #     object_lock_retain_until_date: Time.now,
     #     object_lock_legal_hold_status: "ON", # accepts ON, OFF
+    #     object_lock_event_hold: "ON", # accepts ON, OFF
+    #     object_lock_event_hold_duration_days: 1,
+    #     object_lock_event_hold_duration_years: 1,
     #     expected_bucket_owner: "AccountId",
     #     expected_source_bucket_owner: "AccountId",
     #   })
@@ -711,6 +715,42 @@ module Aws::S3
     #     value of `x-amz-tagging` is the empty value.
     #
     #    </note>
+    # @option options [String] :annotation_directive
+    #   Specifies whether you want to copy annotations from the source object
+    #   or exclude them. If this header isn't specified, `COPY` is the
+    #   default behavior.
+    #
+    #   Valid Values: `COPY | EXCLUDE`
+    #
+    #   You can specify this directive as either an HTTP header
+    #   (`x-amz-object-annotation-directive`) or as a query string parameter.
+    #   Use the query string form when generating presigned URLs that need to
+    #   control annotation copy behavior.
+    #
+    #   When set to `COPY`, you must have `s3:GetObjectAnnotation` permission
+    #   on the source object and `s3:PutObjectAnnotation` permission on the
+    #   destination. Each annotation copied is billed as a separate PUT
+    #   request. If annotations on the source are modified during the copy,
+    #   Amazon S3 returns a retryable error.
+    #
+    #   <note markdown="1"> For directory buckets, annotations are not supported. Use `EXCLUDE` to
+    #   copy objects to directory buckets without errors. If you specify
+    #   `COPY` for a directory bucket, the request returns HTTP 501 (Not
+    #   Implemented).
+    #
+    #    </note>
+    #
+    #   <note markdown="1"> When you copy objects using multipart upload (for example, when the
+    #   Amazon Web Services CLI or Amazon Web Services SDKs use Transfer
+    #   Manager for objects larger than approximately 8 MB), annotations are
+    #   not copied by default. To include annotations, specify `--copy-props
+    #   default` in the Amazon Web Services CLI or the equivalent SDK
+    #   configuration. With this opt-in, the SDK reads source annotations,
+    #   completes the multipart upload, and then writes each annotation to the
+    #   destination. Between the upload completion and the last annotation
+    #   write, the destination object exists without all its annotations.
+    #
+    #    </note>
     # @option options [String] :server_side_encryption
     #   The server-side encryption algorithm used when storing this object in
     #   Amazon S3. Unrecognized or unsupported values won’t write a
@@ -1083,6 +1123,27 @@ module Aws::S3
     #   <note markdown="1"> This functionality is not supported for directory buckets.
     #
     #    </note>
+    # @option options [String] :object_lock_event_hold
+    #   The event hold status to apply to the object copy. Set to `ON` to
+    #   enable or `OFF` to disable.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_days
+    #   The event hold duration in days to apply to the object copy. You
+    #   cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_years
+    #   The event hold duration in years to apply to the object copy. You
+    #   cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
     # @option options [String] :expected_bucket_owner
     #   The account ID of the expected destination bucket owner. If the
     #   account ID that you provide does not match the actual owner of the
@@ -1485,8 +1546,8 @@ module Aws::S3
     #     metadata: {
     #       "MetadataKey" => "MetadataValue",
     #     },
-    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:kms, aws:kms:dsse
-    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP
+    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:backup, aws:kms, aws:kms:dsse
+    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP, AWS_BACKUP_WARM, AWS_BACKUP_LOW_COST_WARM
     #     website_redirect_location: "WebsiteRedirectLocation",
     #     sse_customer_algorithm: "SSECustomerAlgorithm",
     #     sse_customer_key: "SSECustomerKey",
@@ -1499,6 +1560,9 @@ module Aws::S3
     #     object_lock_mode: "GOVERNANCE", # accepts GOVERNANCE, COMPLIANCE
     #     object_lock_retain_until_date: Time.now,
     #     object_lock_legal_hold_status: "ON", # accepts ON, OFF
+    #     object_lock_event_hold: "ON", # accepts ON, OFF
+    #     object_lock_event_hold_duration_days: 1,
+    #     object_lock_event_hold_duration_years: 1,
     #     expected_bucket_owner: "AccountId",
     #     checksum_algorithm: "CRC32", # accepts CRC32, CRC32C, SHA1, SHA256, CRC64NVME, SHA512, MD5, XXHASH64, XXHASH3, XXHASH128
     #     checksum_type: "COMPOSITE", # accepts COMPOSITE, FULL_OBJECT
@@ -2020,6 +2084,27 @@ module Aws::S3
     #   <note markdown="1"> This functionality is not supported for directory buckets.
     #
     #    </note>
+    # @option options [String] :object_lock_event_hold
+    #   Specifies the event hold status to apply to the uploaded object. Set
+    #   to `ON` to enable or `OFF` to disable.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_days
+    #   Specifies the event hold duration in days to apply to the uploaded
+    #   object. You cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_years
+    #   Specifies the event hold duration in years to apply to the uploaded
+    #   object. You cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
     # @option options [String] :expected_bucket_owner
     #   The account ID of the expected bucket owner. If the account ID that
     #   you provide does not match the actual owner of the bucket, the request
@@ -2091,8 +2176,8 @@ module Aws::S3
     #     metadata: {
     #       "MetadataKey" => "MetadataValue",
     #     },
-    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:kms, aws:kms:dsse
-    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP
+    #     server_side_encryption: "AES256", # accepts AES256, aws:fsx, aws:backup, aws:kms, aws:kms:dsse
+    #     storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP, AWS_BACKUP_WARM, AWS_BACKUP_LOW_COST_WARM
     #     website_redirect_location: "WebsiteRedirectLocation",
     #     sse_customer_algorithm: "SSECustomerAlgorithm",
     #     sse_customer_key: "SSECustomerKey",
@@ -2105,6 +2190,9 @@ module Aws::S3
     #     object_lock_mode: "GOVERNANCE", # accepts GOVERNANCE, COMPLIANCE
     #     object_lock_retain_until_date: Time.now,
     #     object_lock_legal_hold_status: "ON", # accepts ON, OFF
+    #     object_lock_event_hold: "ON", # accepts ON, OFF
+    #     object_lock_event_hold_duration_days: 1,
+    #     object_lock_event_hold_duration_years: 1,
     #     expected_bucket_owner: "AccountId",
     #   })
     # @param [Hash] options ({})
@@ -2730,6 +2818,27 @@ module Aws::S3
     #
     #
     #   [1]: https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html
+    # @option options [String] :object_lock_event_hold
+    #   Specifies the event hold status to apply to this object. Set to `ON`
+    #   to enable or `OFF` to disable.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_days
+    #   Specifies the event hold duration in days to apply to this object. You
+    #   cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
+    # @option options [Integer] :object_lock_event_hold_duration_years
+    #   Specifies the event hold duration in years to apply to this object.
+    #   You cannot specify a duration in both days and years.
+    #
+    #   <note markdown="1"> This functionality is not supported for directory buckets.
+    #
+    #    </note>
     # @option options [String] :expected_bucket_owner
     #   The account ID of the expected bucket owner. If the account ID that
     #   you provide does not match the actual owner of the bucket, the request
@@ -2796,7 +2905,7 @@ module Aws::S3
     #           bucket_name: "BucketName", # required
     #           prefix: "LocationPrefix", # required
     #           encryption: {
-    #             encryption_type: "AES256", # required, accepts AES256, aws:fsx, aws:kms, aws:kms:dsse
+    #             encryption_type: "AES256", # required, accepts AES256, aws:fsx, aws:backup, aws:kms, aws:kms:dsse
     #             kms_key_id: "SSEKMSKeyId",
     #             kms_context: "KMSContext",
     #           },
@@ -2827,7 +2936,7 @@ module Aws::S3
     #               value: "MetadataValue",
     #             },
     #           ],
-    #           storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP
+    #           storage_class: "STANDARD", # accepts STANDARD, REDUCED_REDUNDANCY, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, DEEP_ARCHIVE, OUTPOSTS, GLACIER_IR, SNOW, EXPRESS_ONEZONE, FSX_OPENZFS, FSX_ONTAP, AWS_BACKUP_WARM, AWS_BACKUP_LOW_COST_WARM
     #         },
     #       },
     #     },

data/lib/aws-sdk-s3/plugins/http_200_errors.rb

@@ -19,7 +19,7 @@ module Aws
           private_constant :ENCODINGS_TO_FIX
 
           # A regular expression to match detect errors in the response body
-          ERROR_PATTERN = /<\?xml\s[^>]*\?>\s*<Error>/.freeze
+          ERROR_PATTERN = /\A\s*(<\?xml[^>]*\?>\s*)?<Error>/.freeze
           private_constant :ERROR_PATTERN
 
           # A regular expression to match an error message in the response body