aws-sdk-s3 1.103.0 → 1.143.0

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

@@ -23,67 +23,26 @@ each bucket. [Go here for more information](http://docs.aws.amazon.com/AmazonS3/
           operations = config.api.operation_names - [
             :create_bucket, :list_buckets, :delete_bucket
           ]
-          # Need 2 handlers so that the context can be set for other plugins
-          # and to remove :use_accelerate_endpoint from the params.
           handlers.add(
             OptionHandler, step: :initialize, operations: operations
           )
-          handlers.add(
-            AccelerateHandler, step: :build, priority: 11, operations: operations
-          )
         end
 
         # @api private
         class OptionHandler < Seahorse::Client::Handler
           def call(context)
             # 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
-            accelerate = context.config.use_accelerate_endpoint if accelerate.nil?
-            # Raise if :endpoint and dualstack are both provided
-            if accelerate && !context.config.regional_endpoint
-              raise ArgumentError,
-                    'Cannot use both :use_accelerate_endpoint and :endpoint'
+            if accelerate.nil?
+              accelerate = context.config.use_accelerate_endpoint
             end
             context[:use_accelerate_endpoint] = accelerate
             @handler.call(context)
           end
         end
-
-        # @api private
-        class AccelerateHandler < Seahorse::Client::Handler
-          def call(context)
-            if context.config.regional_endpoint && context[:use_accelerate_endpoint]
-              dualstack = !!context[:use_dualstack_endpoint]
-              use_accelerate_endpoint(context, dualstack)
-            end
-            @handler.call(context)
-          end
-
-          private
-
-          def use_accelerate_endpoint(context, dualstack)
-            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' if 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)
-              raise ArgumentError,
-                    'Unable to use `use_accelerate_endpoint: true` on buckets '\
-                    'with non-DNS compatible names.'
-            end
-          end
-        end
       end
     end
   end

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)
-
-                fips = false
-                if resolved_region.include?('fips')
-                  fips = true
-                  resolved_region = resolved_region.gsub('fips-', '')
-                                                   .gsub('-fips', '')
-                end
-
-                context.metadata[:s3_arn] = {
-                  arn: arn,
-                  resolved_region: resolved_region,
-                  fips: fips,
-                  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 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
-          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.include?('fips')
-              [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,57 +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
-              if region.include?('fips')
-                # If ARN type doesn't support FIPS but the client region is FIPS
-                unless arn.support_fips?
-                  raise ArgumentError,
-                        'FIPS client regions are not supported for this type '\
-                        'of ARN.'
-                end
-
-                fips = true
-                # Normalize the region so we can compare partition and regions
-                region = region.gsub('fips-', '').gsub('-fips', '')
-              end
-
-              # 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 || fips) && 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) 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,18 +5,8 @@ module Aws
     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: 11)
         end
 
         # @api private
@@ -27,54 +17,10 @@ for all operations.
               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)
-            if context.config.regional_endpoint && use_dualstack_endpoint?(context)
-              apply_dualstack_endpoint(context)
-            end
-            @handler.call(context)
-          end
-
-          private
-          def apply_dualstack_endpoint(context)
-            bucket_name = context.params[:bucket]
-            region = context.config.region
-            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