aws-sdk-s3 1.113.0 → 1.133.0

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

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../arn/access_point_arn'
-require_relative '../arn/object_lambda_arn'
-require_relative '../arn/outpost_access_point_arn'
-require_relative '../arn/multi_region_access_point_arn'
-
 module Aws
   module S3
     module Plugins
@@ -36,150 +31,9 @@ result in cross region requests.
           resolve_s3_disable_multiregion_access_points(cfg)
         end
 
-        # param validator is validate:50
-        # endpoint is build:90 (populates the URI for the first time)
-        # endpoint pattern is build:10
-        def add_handlers(handlers, _config)
-          handlers.add(ARNHandler, step: :validate, priority: 75)
-          handlers.add(UrlHandler)
-        end
-
-        # After extracting out any ARN input, resolve a new URL with it.
-        class UrlHandler < Seahorse::Client::Handler
-          def call(context)
-            if context.metadata[:s3_arn]
-              ARN.resolve_url!(
-                context.http_request.endpoint,
-                context.metadata[:s3_arn][:arn],
-                context.metadata[:s3_arn][:resolved_region],
-                context.metadata[:s3_arn][:fips],
-                context.metadata[:s3_arn][:dualstack],
-                # if regional_endpoint is false, a custom endpoint was provided
-                # in this case, we want to prefix the endpoint using the ARN
-                !context.config.regional_endpoint
-              )
-            end
-            @handler.call(context)
-          end
-        end
-
-        # This plugin will extract out any ARN input and set context for other
-        # plugins to use without having to translate the ARN again.
-        class ARNHandler < Seahorse::Client::Handler
-          def call(context)
-            bucket_member = _bucket_member(context.operation.input.shape)
-            if bucket_member && (bucket = context.params[bucket_member])
-              resolved_region, arn = ARN.resolve_arn!(
-                bucket,
-                context.config.region,
-                context.config.s3_use_arn_region
-              )
-              if arn
-                validate_config!(context, arn)
-
-                context.metadata[:s3_arn] = {
-                  arn: arn,
-                  resolved_region: resolved_region,
-                  fips: context.config.use_fips_endpoint,
-                  dualstack: extract_dualstack_config!(context)
-                }
-              end
-            end
-            @handler.call(context)
-          end
-
-          private
-
-          def _bucket_member(input)
-            input.members.each do |member, ref|
-              return member if ref.shape.name == 'BucketName'
-            end
-            nil
-          end
-
-          # other plugins use dualstack so disable it when we're done
-          def extract_dualstack_config!(context)
-            dualstack = context[:use_dualstack_endpoint]
-            context[:use_dualstack_endpoint] = false if dualstack
-            dualstack
-          end
-
-          def validate_config!(context, arn)
-            if context.config.force_path_style
-              raise ArgumentError,
-                    'Cannot provide an Access Point ARN when '\
-                    '`:force_path_style` is set to true.'
-            end
-
-            if context.config.use_accelerate_endpoint
-              raise ArgumentError,
-                    'Cannot provide an Access Point ARN when '\
-                    '`:use_accelerate_endpoint` is set to true.'
-            end
-
-            if !arn.support_dualstack? && context[:use_dualstack_endpoint]
-              raise ArgumentError,
-                    'Cannot provide an Outpost Access Point, Object Lambda, '\
-                    'or Multi-region Access Point ARN'\
-                    ' when `:use_dualstack_endpoint` is set to true.'
-            end
-
-            if arn.region.empty? && context.config.s3_disable_multiregion_access_points
-              raise ArgumentError,
-                    'Cannot provide a Multi-region Access Point ARN with '\
-                    '`:s3_disable_multiregion_access_points` set to true'
-            end
-
-            if context.config.use_fips_endpoint && !arn.support_fips?
-              raise ArgumentError,
-                    'FIPS client regions are not supported for this type '\
-                    'of ARN.'
-            end
-          end
-        end
-
         class << self
-          # @api private
-          def resolve_arn!(member_value, region, use_arn_region)
-            if Aws::ARNParser.arn?(member_value)
-              arn = Aws::ARNParser.parse(member_value)
-              s3_arn = resolve_arn_type!(arn)
-              s3_arn.validate_arn!
-              validate_region_config!(s3_arn, region, use_arn_region)
-              region = s3_arn.region if use_arn_region
-              [region, s3_arn]
-            else
-              [region]
-            end
-          end
-
-          # @api private
-          def resolve_url!(url, arn, region, fips = false, dualstack = false, has_custom_endpoint = false)
-            custom_endpoint = url.host if has_custom_endpoint
-            url.host = arn.host_url(region, fips, dualstack, custom_endpoint)
-            url.path = url_path(url.path, arn)
-            url
-          end
-
           private
 
-          def resolve_arn_type!(arn)
-            case arn.service
-            when 's3'
-              arn.region.empty? ?
-                Aws::S3::MultiRegionAccessPointARN.new(arn.to_h) :
-                Aws::S3::AccessPointARN.new(arn.to_h)
-            when 's3-outposts'
-              Aws::S3::OutpostAccessPointARN.new(arn.to_h)
-            when 's3-object-lambda'
-              Aws::S3::ObjectLambdaARN.new(arn.to_h)
-            else
-              raise ArgumentError,
-                    'Only Access Point, Outposts, and Object Lambdas ARNs '\
-                    'are currently supported.'
-            end
-          end
-
           def resolve_s3_use_arn_region(cfg)
             value = ENV['AWS_S3_USE_ARN_REGION'] ||
                     Aws.shared_config.s3_use_arn_region(profile: cfg.profile) ||
@@ -209,44 +63,6 @@ result in cross region requests.
             end
             value
           end
-
-          # Remove ARN from the path because we've already set the new host
-          def url_path(path, arn)
-            path = path.sub("/#{Seahorse::Util.uri_escape(arn.to_s)}", '')
-                       .sub("/#{arn}", '')
-            "/#{path}" unless path =~ /^\//
-            path
-          end
-
-          def validate_region_config!(arn, region, use_arn_region)
-            if ['s3-external-1', 'aws-global'].include?(region)
-              # These "regions" are not regional endpoints
-              unless use_arn_region
-                raise Aws::Errors::InvalidARNRegionError,
-                      'Configured client region is not a regional endpoint.'
-              end
-              # These "regions" are in the AWS partition
-              # Cannot use ARN region unless it's the same partition
-              unless arn.partition == 'aws'
-                raise Aws::Errors::InvalidARNPartitionError
-              end
-            else
-              # use_arn_region does not apply to MRAP (global) arns
-              unless arn.region.empty?
-                # Raise if the ARN and client regions are in different partitions
-                if use_arn_region &&
-                   !Aws::Partitions.partition(arn.partition).region?(region)
-                  raise Aws::Errors::InvalidARNPartitionError
-                end
-
-                # Raise if regions mismatch
-                # Either when it's a fips client or not using the ARN region
-                if !use_arn_region && region != arn.region
-                  raise Aws::Errors::InvalidARNRegionError
-                end
-              end
-            end
-          end
         end
       end
     end

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

@@ -23,45 +23,10 @@ When set to `true`, the bucket name is always left in the
 request URI and never moved to the host as a sub-domain.
           DOCS
 
-        def add_handlers(handlers, config)
-          handlers.add(Handler, priority: 48) unless config.force_path_style
-        end
-
-        # @api private
-        class Handler < Seahorse::Client::Handler
-
-          def call(context)
-            move_dns_compat_bucket_to_subdomain(context)
-            @handler.call(context)
-          end
-
-          private
-
-          def move_dns_compat_bucket_to_subdomain(context)
-            bucket_name = context.params[:bucket]
-            endpoint = context.http_request.endpoint
-            if bucket_name &&
-               BucketDns.dns_compatible?(bucket_name, https?(endpoint)) &&
-               context.operation_name.to_s != 'get_bucket_location'
-              move_bucket_to_subdomain(bucket_name, endpoint)
-            end
-          end
-
-          def move_bucket_to_subdomain(bucket_name, endpoint)
-            endpoint.host = "#{bucket_name}.#{endpoint.host}"
-            path = endpoint.path.sub("/#{bucket_name}", '')
-            path = "/#{path}" unless path.match(/^\//)
-            endpoint.path = path
-          end
-
-          def https?(uri)
-            uri.scheme == 'https'
-          end
-
-        end
-
+        # These class methods were originally used in a handler in this plugin.
+        # SigV2 legacy signer needs this logic so we keep it here as utility.
+        # New endpoint resolution will check this as a matcher.
         class << self
-
           # @param [String] bucket_name
           # @param [Boolean] ssl
           # @return [Boolean]
@@ -81,7 +46,6 @@ request URI and never moved to the host as a sub-domain.
             bucket_name !~ /(\d+\.){3}\d+/ &&
             bucket_name !~ /[.-]{2}/
           end
-
         end
       end
     end

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

@@ -13,12 +13,7 @@ module Aws
           def call(context)
             bucket_member = _bucket_member(context.operation.input.shape)
             if bucket_member && (bucket = context.params[bucket_member])
-              _resolved_region, arn = ARN.resolve_arn!(
-                bucket,
-                context.config.region,
-                context.config.s3_use_arn_region
-              )
-              if !arn && bucket.include?('/')
+              if !Aws::ARNParser.arn?(bucket) && bucket.include?('/')
                 raise ArgumentError,
                       'bucket name must not contain a forward-slash (/)'
               end

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

@@ -5,9 +5,8 @@ module Aws
     module Plugins
       # @api private
       class Dualstack < Seahorse::Client::Plugin
-        def add_handlers(handlers, config)
+        def add_handlers(handlers, _config)
           handlers.add(OptionHandler, step: :initialize)
-          handlers.add(DualstackHandler, step: :build, priority: 49)
         end
 
         # @api private
@@ -18,57 +17,10 @@ module Aws
               dualstack = context.params.delete(:use_dualstack_endpoint)
             end
             dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
-            # Raise if :endpoint and dualstack are both provided
-            if dualstack && !context.config.regional_endpoint
-              raise ArgumentError,
-                    'Cannot use both :use_dualstack_endpoint and :endpoint'
-            end
             context[:use_dualstack_endpoint] = dualstack
             @handler.call(context)
           end
         end
-
-        # @api private
-        class DualstackHandler < Seahorse::Client::Handler
-          def call(context)
-            # only rewrite the endpoint if it's not a custom endpoint
-            # accelerate/ARN already handle dualstack cases, so ignore these
-            # check to see if dualstack is on but configured off via operation
-            if context.config.regional_endpoint &&
-               use_dualstack_endpoint?(context)
-              apply_dualstack_endpoint(context)
-            end
-            @handler.call(context)
-          end
-
-          private
-
-          def apply_dualstack_endpoint(context)
-            new_endpoint = Aws::Partitions::EndpointProvider.resolve(
-              context.config.region,
-              's3',
-              'regional',
-              {
-                dualstack: context[:use_dualstack_endpoint],
-                fips: context.config.use_fips_endpoint
-              }
-            )
-            endpoint = URI.parse(context.http_request.endpoint.to_s)
-            endpoint.host = URI.parse(new_endpoint).host
-            context.http_request.endpoint = endpoint
-          end
-
-          def use_dualstack_endpoint?(context)
-            # case when dualstack is turned off via operation
-            (context[:use_dualstack_endpoint] ||
-              context.config.use_dualstack_endpoint) &&
-              # accelerate plugin already applies dualstack
-              !context[:use_accelerate_endpoint] &&
-              # arns handle dualstack
-              !context.metadata[:s3_arn]
-          end
-        end
-
       end
     end
   end

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

@@ -0,0 +1,262 @@
+# 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/version-3/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+
+module Aws::S3
+  module Plugins
+    class Endpoints < Seahorse::Client::Plugin
+      option(
+        :endpoint_provider,
+        doc_type: 'Aws::S3::EndpointProvider',
+        docstring: 'The endpoint provider used to resolve endpoints. Any '\
+                   'object that responds to `#resolve_endpoint(parameters)` '\
+                   'where `parameters` is a Struct similar to '\
+                   '`Aws::S3::EndpointParameters`'
+      ) do |cfg|
+        Aws::S3::EndpointProvider.new
+      end
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          # If endpoint was discovered, do not resolve or apply the endpoint.
+          unless context[:discovered_endpoint]
+            params = parameters_for_operation(context)
+            endpoint = context.config.endpoint_provider.resolve_endpoint(params)
+
+            context.http_request.endpoint = endpoint.url
+            apply_endpoint_headers(context, endpoint.headers)
+          end
+
+          context[:endpoint_params] = params
+          context[:auth_scheme] =
+            Aws::Endpoints.resolve_auth_scheme(context, endpoint)
+
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_endpoint_headers(context, headers)
+          headers.each do |key, values|
+            value = values
+              .compact
+              .map { |s| Seahorse::Util.escape_header_list_string(s.to_s) }
+              .join(',')
+
+            context.http_request.headers[key] = value
+          end
+        end
+
+        def parameters_for_operation(context)
+          case context.operation_name
+          when :abort_multipart_upload
+            Aws::S3::Endpoints::AbortMultipartUpload.build(context)
+          when :complete_multipart_upload
+            Aws::S3::Endpoints::CompleteMultipartUpload.build(context)
+          when :copy_object
+            Aws::S3::Endpoints::CopyObject.build(context)
+          when :create_bucket
+            Aws::S3::Endpoints::CreateBucket.build(context)
+          when :create_multipart_upload
+            Aws::S3::Endpoints::CreateMultipartUpload.build(context)
+          when :delete_bucket
+            Aws::S3::Endpoints::DeleteBucket.build(context)
+          when :delete_bucket_analytics_configuration
+            Aws::S3::Endpoints::DeleteBucketAnalyticsConfiguration.build(context)
+          when :delete_bucket_cors
+            Aws::S3::Endpoints::DeleteBucketCors.build(context)
+          when :delete_bucket_encryption
+            Aws::S3::Endpoints::DeleteBucketEncryption.build(context)
+          when :delete_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::DeleteBucketIntelligentTieringConfiguration.build(context)
+          when :delete_bucket_inventory_configuration
+            Aws::S3::Endpoints::DeleteBucketInventoryConfiguration.build(context)
+          when :delete_bucket_lifecycle
+            Aws::S3::Endpoints::DeleteBucketLifecycle.build(context)
+          when :delete_bucket_metrics_configuration
+            Aws::S3::Endpoints::DeleteBucketMetricsConfiguration.build(context)
+          when :delete_bucket_ownership_controls
+            Aws::S3::Endpoints::DeleteBucketOwnershipControls.build(context)
+          when :delete_bucket_policy
+            Aws::S3::Endpoints::DeleteBucketPolicy.build(context)
+          when :delete_bucket_replication
+            Aws::S3::Endpoints::DeleteBucketReplication.build(context)
+          when :delete_bucket_tagging
+            Aws::S3::Endpoints::DeleteBucketTagging.build(context)
+          when :delete_bucket_website
+            Aws::S3::Endpoints::DeleteBucketWebsite.build(context)
+          when :delete_object
+            Aws::S3::Endpoints::DeleteObject.build(context)
+          when :delete_object_tagging
+            Aws::S3::Endpoints::DeleteObjectTagging.build(context)
+          when :delete_objects
+            Aws::S3::Endpoints::DeleteObjects.build(context)
+          when :delete_public_access_block
+            Aws::S3::Endpoints::DeletePublicAccessBlock.build(context)
+          when :get_bucket_accelerate_configuration
+            Aws::S3::Endpoints::GetBucketAccelerateConfiguration.build(context)
+          when :get_bucket_acl
+            Aws::S3::Endpoints::GetBucketAcl.build(context)
+          when :get_bucket_analytics_configuration
+            Aws::S3::Endpoints::GetBucketAnalyticsConfiguration.build(context)
+          when :get_bucket_cors
+            Aws::S3::Endpoints::GetBucketCors.build(context)
+          when :get_bucket_encryption
+            Aws::S3::Endpoints::GetBucketEncryption.build(context)
+          when :get_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::GetBucketIntelligentTieringConfiguration.build(context)
+          when :get_bucket_inventory_configuration
+            Aws::S3::Endpoints::GetBucketInventoryConfiguration.build(context)
+          when :get_bucket_lifecycle
+            Aws::S3::Endpoints::GetBucketLifecycle.build(context)
+          when :get_bucket_lifecycle_configuration
+            Aws::S3::Endpoints::GetBucketLifecycleConfiguration.build(context)
+          when :get_bucket_location
+            Aws::S3::Endpoints::GetBucketLocation.build(context)
+          when :get_bucket_logging
+            Aws::S3::Endpoints::GetBucketLogging.build(context)
+          when :get_bucket_metrics_configuration
+            Aws::S3::Endpoints::GetBucketMetricsConfiguration.build(context)
+          when :get_bucket_notification
+            Aws::S3::Endpoints::GetBucketNotification.build(context)
+          when :get_bucket_notification_configuration
+            Aws::S3::Endpoints::GetBucketNotificationConfiguration.build(context)
+          when :get_bucket_ownership_controls
+            Aws::S3::Endpoints::GetBucketOwnershipControls.build(context)
+          when :get_bucket_policy
+            Aws::S3::Endpoints::GetBucketPolicy.build(context)
+          when :get_bucket_policy_status
+            Aws::S3::Endpoints::GetBucketPolicyStatus.build(context)
+          when :get_bucket_replication
+            Aws::S3::Endpoints::GetBucketReplication.build(context)
+          when :get_bucket_request_payment
+            Aws::S3::Endpoints::GetBucketRequestPayment.build(context)
+          when :get_bucket_tagging
+            Aws::S3::Endpoints::GetBucketTagging.build(context)
+          when :get_bucket_versioning
+            Aws::S3::Endpoints::GetBucketVersioning.build(context)
+          when :get_bucket_website
+            Aws::S3::Endpoints::GetBucketWebsite.build(context)
+          when :get_object
+            Aws::S3::Endpoints::GetObject.build(context)
+          when :get_object_acl
+            Aws::S3::Endpoints::GetObjectAcl.build(context)
+          when :get_object_attributes
+            Aws::S3::Endpoints::GetObjectAttributes.build(context)
+          when :get_object_legal_hold
+            Aws::S3::Endpoints::GetObjectLegalHold.build(context)
+          when :get_object_lock_configuration
+            Aws::S3::Endpoints::GetObjectLockConfiguration.build(context)
+          when :get_object_retention
+            Aws::S3::Endpoints::GetObjectRetention.build(context)
+          when :get_object_tagging
+            Aws::S3::Endpoints::GetObjectTagging.build(context)
+          when :get_object_torrent
+            Aws::S3::Endpoints::GetObjectTorrent.build(context)
+          when :get_public_access_block
+            Aws::S3::Endpoints::GetPublicAccessBlock.build(context)
+          when :head_bucket
+            Aws::S3::Endpoints::HeadBucket.build(context)
+          when :head_object
+            Aws::S3::Endpoints::HeadObject.build(context)
+          when :list_bucket_analytics_configurations
+            Aws::S3::Endpoints::ListBucketAnalyticsConfigurations.build(context)
+          when :list_bucket_intelligent_tiering_configurations
+            Aws::S3::Endpoints::ListBucketIntelligentTieringConfigurations.build(context)
+          when :list_bucket_inventory_configurations
+            Aws::S3::Endpoints::ListBucketInventoryConfigurations.build(context)
+          when :list_bucket_metrics_configurations
+            Aws::S3::Endpoints::ListBucketMetricsConfigurations.build(context)
+          when :list_buckets
+            Aws::S3::Endpoints::ListBuckets.build(context)
+          when :list_multipart_uploads
+            Aws::S3::Endpoints::ListMultipartUploads.build(context)
+          when :list_object_versions
+            Aws::S3::Endpoints::ListObjectVersions.build(context)
+          when :list_objects
+            Aws::S3::Endpoints::ListObjects.build(context)
+          when :list_objects_v2
+            Aws::S3::Endpoints::ListObjectsV2.build(context)
+          when :list_parts
+            Aws::S3::Endpoints::ListParts.build(context)
+          when :put_bucket_accelerate_configuration
+            Aws::S3::Endpoints::PutBucketAccelerateConfiguration.build(context)
+          when :put_bucket_acl
+            Aws::S3::Endpoints::PutBucketAcl.build(context)
+          when :put_bucket_analytics_configuration
+            Aws::S3::Endpoints::PutBucketAnalyticsConfiguration.build(context)
+          when :put_bucket_cors
+            Aws::S3::Endpoints::PutBucketCors.build(context)
+          when :put_bucket_encryption
+            Aws::S3::Endpoints::PutBucketEncryption.build(context)
+          when :put_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::PutBucketIntelligentTieringConfiguration.build(context)
+          when :put_bucket_inventory_configuration
+            Aws::S3::Endpoints::PutBucketInventoryConfiguration.build(context)
+          when :put_bucket_lifecycle
+            Aws::S3::Endpoints::PutBucketLifecycle.build(context)
+          when :put_bucket_lifecycle_configuration
+            Aws::S3::Endpoints::PutBucketLifecycleConfiguration.build(context)
+          when :put_bucket_logging
+            Aws::S3::Endpoints::PutBucketLogging.build(context)
+          when :put_bucket_metrics_configuration
+            Aws::S3::Endpoints::PutBucketMetricsConfiguration.build(context)
+          when :put_bucket_notification
+            Aws::S3::Endpoints::PutBucketNotification.build(context)
+          when :put_bucket_notification_configuration
+            Aws::S3::Endpoints::PutBucketNotificationConfiguration.build(context)
+          when :put_bucket_ownership_controls
+            Aws::S3::Endpoints::PutBucketOwnershipControls.build(context)
+          when :put_bucket_policy
+            Aws::S3::Endpoints::PutBucketPolicy.build(context)
+          when :put_bucket_replication
+            Aws::S3::Endpoints::PutBucketReplication.build(context)
+          when :put_bucket_request_payment
+            Aws::S3::Endpoints::PutBucketRequestPayment.build(context)
+          when :put_bucket_tagging
+            Aws::S3::Endpoints::PutBucketTagging.build(context)
+          when :put_bucket_versioning
+            Aws::S3::Endpoints::PutBucketVersioning.build(context)
+          when :put_bucket_website
+            Aws::S3::Endpoints::PutBucketWebsite.build(context)
+          when :put_object
+            Aws::S3::Endpoints::PutObject.build(context)
+          when :put_object_acl
+            Aws::S3::Endpoints::PutObjectAcl.build(context)
+          when :put_object_legal_hold
+            Aws::S3::Endpoints::PutObjectLegalHold.build(context)
+          when :put_object_lock_configuration
+            Aws::S3::Endpoints::PutObjectLockConfiguration.build(context)
+          when :put_object_retention
+            Aws::S3::Endpoints::PutObjectRetention.build(context)
+          when :put_object_tagging
+            Aws::S3::Endpoints::PutObjectTagging.build(context)
+          when :put_public_access_block
+            Aws::S3::Endpoints::PutPublicAccessBlock.build(context)
+          when :restore_object
+            Aws::S3::Endpoints::RestoreObject.build(context)
+          when :select_object_content
+            Aws::S3::Endpoints::SelectObjectContent.build(context)
+          when :upload_part
+            Aws::S3::Endpoints::UploadPart.build(context)
+          when :upload_part_copy
+            Aws::S3::Endpoints::UploadPartCopy.build(context)
+          when :write_get_object_response
+            Aws::S3::Endpoints::WriteGetObjectResponse.build(context)
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :build, priority: 75)
+      end
+    end
+  end
+end

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

@@ -16,7 +16,8 @@ module Aws
 
           def call(context)
             body = context.http_request.body
-            if body.respond_to?(:size) && body.size > 0
+            if body.respond_to?(:size) && body.size > 0 &&
+               !context[:use_accelerate_endpoint]
               context.http_request.headers['expect'] = '100-continue'
             end
             @handler.call(context)

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

@@ -16,35 +16,6 @@ Defaults to `legacy` mode which uses the global endpoint.
           resolve_iad_regional_endpoint(cfg)
         end
 
-        def add_handlers(handlers, config)
-          # only modify non-custom endpoints
-          if config.regional_endpoint && config.region == 'us-east-1'
-            handlers.add(Handler)
-          end
-        end
-
-        # @api private
-        class Handler < Seahorse::Client::Handler
-
-          def call(context)
-            # WriteGetObjectResponse does not have a global endpoint
-            # ARNs are regionalized, so don't touch those either.
-            if context.operation.name != 'WriteGetObjectResponse' &&
-               context.config.s3_us_east_1_regional_endpoint == 'legacy' &&
-               !context.metadata[:s3_arn]
-              host = context.http_request.endpoint.host
-              legacy_host = IADRegionalEndpoint.legacy_host(host)
-              context.http_request.endpoint.host = legacy_host
-            end
-            @handler.call(context)
-          end
-
-        end
-
-        def self.legacy_host(host)
-          host.sub(".us-east-1", '')
-        end
-
         private
 
         def self.resolve_iad_regional_endpoint(cfg)