aws-sdk-s3 1.53.0 → 1.146.0

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

@@ -1,94 +1,47 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins
-
       # Provides support for using `Aws::S3::Client` with Amazon S3 Transfer
       # Acceleration.
       #
       # Go here for more information about transfer acceleration:
       # [http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html](http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html)
       class Accelerate < Seahorse::Client::Plugin
-
-        option(:use_accelerate_endpoint,
+        option(
+          :use_accelerate_endpoint,
           default: false,
           doc_type: 'Boolean',
           docstring: <<-DOCS)
 When set to `true`, accelerated bucket endpoints will be used
 for all object operations. You must first enable accelerate for
-each bucket.  [Go here for more information](http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html).
+each bucket. [Go here for more information](http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html).
           DOCS
 
         def add_handlers(handlers, config)
           operations = config.api.operation_names - [
-            :create_bucket, :list_buckets, :delete_bucket,
+            :create_bucket, :list_buckets, :delete_bucket
           ]
-          handlers.add(OptionHandler, step: :initialize, operations: operations)
-          handlers.add(AccelerateHandler, step: :build, priority: 0, operations: operations)
+          handlers.add(
+            OptionHandler, step: :initialize, operations: operations
+          )
         end
 
         # @api private
         class OptionHandler < Seahorse::Client::Handler
           def call(context)
-            accelerate = context.params.delete(:use_accelerate_endpoint)
-            accelerate = context.config.use_accelerate_endpoint if accelerate.nil?
-            context[:use_accelerate_endpoint] = accelerate
-            @handler.call(context)
-          end
-        end
-
-        # @api private
-        class AccelerateHandler < Seahorse::Client::Handler
-
-          def call(context)
-            if context[:use_accelerate_endpoint]
-              if context[:use_dualstack_endpoint]
-                use_combined_accelerate_dualstack_endpoint(context)
-              else
-                use_accelerate_endpoint(context)
-              end
+            # Support client configuration and per-operation configuration
+            # TODO: move this to an options hash and warn here.
+            if context.params.is_a?(Hash)
+              accelerate = context.params.delete(:use_accelerate_endpoint)
             end
-            @handler.call(context)
-          end
-
-          private
-
-          def use_accelerate_endpoint(context)
-            bucket_name = context.params[:bucket]
-            validate_bucket_name!(bucket_name)
-            endpoint = URI.parse(context.http_request.endpoint.to_s)
-            endpoint.scheme = 'https'
-            endpoint.port = 443
-            endpoint.host = "#{bucket_name}.s3-accelerate.amazonaws.com"
-            context.http_request.endpoint = endpoint.to_s
-            # s3 accelerate endpoint doesn't work with 'expect' header
-            context.http_request.headers.delete('expect')
-          end
-
-          def use_combined_accelerate_dualstack_endpoint(context)
-            bucket_name = context.params[:bucket]
-            validate_bucket_name!(bucket_name)
-            endpoint = URI.parse(context.http_request.endpoint.to_s)
-            endpoint.scheme = 'https'
-            endpoint.port = 443
-            endpoint.host = "#{bucket_name}.s3-accelerate.dualstack.amazonaws.com"
-            context.http_request.endpoint = endpoint.to_s
-            # s3 accelerate endpoint doesn't work with 'expect' header
-            context.http_request.headers.delete('expect')
-          end
-
-          def validate_bucket_name!(bucket_name)
-            unless BucketDns.dns_compatible?(bucket_name, _ssl = true)
-              msg = "unable to use `accelerate: true` on buckets with "
-              msg << "non-DNS compatible names"
-              raise ArgumentError, msg
-            end
-            if bucket_name.include?('.')
-              msg = "unable to use `accelerate: true` on buckets with dots"
-              msg << "in their name: #{bucket_name.inspect}"
-              raise ArgumentError, msg
+            if accelerate.nil?
+              accelerate = context.config.use_accelerate_endpoint
             end
+            context[:use_accelerate_endpoint] = accelerate
+            @handler.call(context)
           end
-
         end
       end
     end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+      # When an accesspoint ARN is provided for :bucket in S3 operations, this
+      # plugin resolves the request endpoint from the ARN when possible.
+      # @api private
+      class ARN < Seahorse::Client::Plugin
+        option(
+          :s3_use_arn_region,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS) do |cfg|
+For S3 ARNs passed into the `:bucket` parameter, this option will
+use the region in the ARN, allowing for cross-region requests to
+be made. Set to `false` to use the client's region instead.
+          DOCS
+          resolve_s3_use_arn_region(cfg)
+        end
+
+        option(
+          :s3_disable_multiregion_access_points,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS) do |cfg|
+When set to `false` this will option will raise errors when multi-region
+access point ARNs are used.  Multi-region access points can potentially
+result in cross region requests.
+        DOCS
+          resolve_s3_disable_multiregion_access_points(cfg)
+        end
+
+        class << self
+          private
+
+          def resolve_s3_use_arn_region(cfg)
+            value = ENV['AWS_S3_USE_ARN_REGION'] ||
+                    Aws.shared_config.s3_use_arn_region(profile: cfg.profile) ||
+                    'true'
+            value = Aws::Util.str_2_bool(value)
+            # Raise if provided value is not true or false
+            if value.nil?
+              raise ArgumentError,
+                    'Must provide either `true` or `false` for the '\
+                    '`s3_use_arn_region` profile option or for '\
+                    "ENV['AWS_S3_USE_ARN_REGION']."
+            end
+            value
+          end
+
+          def resolve_s3_disable_multiregion_access_points(cfg)
+            value = ENV['AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS'] ||
+              Aws.shared_config.s3_disable_multiregion_access_points(profile: cfg.profile) ||
+              'false'
+            value = Aws::Util.str_2_bool(value)
+            # Raise if provided value is not true or false
+            if value.nil?
+              raise ArgumentError,
+                    'Must provide either `true` or `false` for '\
+                    's3_use_arn_region profile option or for '\
+                    "ENV['AWS_S3_USE_ARN_REGION']"
+            end
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins
@@ -21,47 +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) 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'
-            then
-              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]
@@ -73,15 +38,14 @@ request URI and never moved to the host as a sub-domain.
             end
           end
 
-          private
-
+          # @param [String] bucket_name
+          # @return [Boolean]
           def valid_subdomain?(bucket_name)
             bucket_name.size < 64 &&
             bucket_name =~ /^[a-z0-9][a-z0-9.-]+[a-z0-9]$/ &&
             bucket_name !~ /(\d+\.){3}\d+/ &&
             bucket_name !~ /[.-]{2}/
           end
-
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins
@@ -5,14 +7,29 @@ module Aws
       class BucketNameRestrictions < Seahorse::Client::Plugin
         class Handler < Seahorse::Client::Handler
 
+          # Useful because Aws::S3::Errors::SignatureDoesNotMatch is thrown
+          # when passed a bucket with a forward slash. Instead provide a more
+          # helpful error. Ideally should not be a plugin?
           def call(context)
-            if context.params.key?(:bucket) && context.params[:bucket].include?('/')
-              msg = ":bucket option must not contain a forward-slash (/)"
-              raise ArgumentError, msg
+            bucket_member = _bucket_member(context.operation.input.shape)
+            if bucket_member && (bucket = context.params[bucket_member])
+              if !Aws::ARNParser.arn?(bucket) && bucket.include?('/')
+                raise ArgumentError,
+                      'bucket name must not contain a forward-slash (/)'
+              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
+
         end
 
         handler(Handler)

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

@@ -1,69 +1,26 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins
       # @api private
       class Dualstack < Seahorse::Client::Plugin
-
-        option(:use_dualstack_endpoint,
-          default: false,
-          doc_type: 'Boolean',
-          docstring: <<-DOCS)
-When set to `true`, IPv6-compatible bucket endpoints will be used
-for all operations.
-          DOCS
-
-        def add_handlers(handlers, config)
+        def add_handlers(handlers, _config)
           handlers.add(OptionHandler, step: :initialize)
-          handlers.add(DualstackHandler, step: :build, priority: 0)
         end
 
         # @api private
         class OptionHandler < Seahorse::Client::Handler
           def call(context)
-            dualstack = context.params.delete(:use_dualstack_endpoint)
+            # Support client configuration and per-operation configuration
+            if context.params.is_a?(Hash)
+              dualstack = context.params.delete(:use_dualstack_endpoint)
+            end
             dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
             context[:use_dualstack_endpoint] = dualstack
             @handler.call(context)
           end
         end
-
-        # @api private
-        class DualstackHandler < Seahorse::Client::Handler
-          def call(context)
-            apply_dualstack_endpoint(context) if use_dualstack_endpoint?(context)
-            @handler.call(context)
-          end
-
-          private
-          def apply_dualstack_endpoint(context)
-            bucket_name = context.params[:bucket]
-            region = context.config.region
-            context.config.force_path_style
-            dns_suffix = Aws::Partitions::EndpointProvider.dns_suffix_for(region)
-
-            if use_bucket_dns?(bucket_name, context)
-              host = "#{bucket_name}.s3.dualstack.#{region}.#{dns_suffix}"
-            else
-              host = "s3.dualstack.#{region}.#{dns_suffix}"
-            end
-            endpoint = URI.parse(context.http_request.endpoint.to_s)
-            endpoint.scheme = context.http_request.endpoint.scheme
-            endpoint.port = context.http_request.endpoint.port
-            endpoint.host = host
-            context.http_request.endpoint = endpoint.to_s
-          end
-
-          def use_bucket_dns?(bucket_name, context)
-            ssl = context.http_request.endpoint.scheme == "https"
-            bucket_name && BucketDns.dns_compatible?(bucket_name, ssl) &&
-              !context.config.force_path_style
-          end
-
-          def use_dualstack_endpoint?(context)
-            context[:use_dualstack_endpoint] && !context[:use_accelerate_endpoint]
-          end
-        end
-
       end
     end
   end

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

@@ -0,0 +1,274 @@
+# 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',
+        rbs_type: 'untyped',
+        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
+
+      option(
+        :disable_s3_express_session_auth,
+        doc_type: 'Boolean',
+        default: nil,
+        docstring: "Parameter to indicate whether S3Express session auth should be disabled")
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          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)
+
+            context[:endpoint_params] = params
+            context[:endpoint_properties] = endpoint.properties
+          end
+
+          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 :create_session
+            Aws::S3::Endpoints::CreateSession.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_directory_buckets
+            Aws::S3::Endpoints::ListDirectoryBuckets.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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins
@@ -13,10 +15,9 @@ module Aws
         class Handler < Seahorse::Client::Handler
 
           def call(context)
-            if
-              context.http_request.body &&
-              context.http_request.body.size > 0
-            then
+            body = context.http_request.body
+            if body.respond_to?(:size) && body.size > 0 &&
+               !context[:use_accelerate_endpoint]
               context.http_request.headers['expect'] = '100-continue'
             end
             @handler.call(context)