aws-sdk-core 2.11.386 → 3.71.0

data/lib/aws-sdk-core/plugins/s3_accelerate.rb

@@ -1,90 +0,0 @@
-module Aws
-  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)
-    #
-    # @seahorse.client.option [Boolean] :use_accelerate_endpoint (false)
-    #   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).
-    #
-    class S3Accelerate < Seahorse::Client::Plugin
-
-      option(:use_accelerate_endpoint, false)
-      option(:use_dualstack_endpoint, false)
-
-      def add_handlers(handlers, config)
-        operations = config.api.operation_names - [
-          :create_bucket, :list_buckets, :delete_bucket,
-        ]
-        handlers.add(OptionHandler, step: :initialize, operations: operations)
-        handlers.add(AccelerateHandler, step: :build, priority: 0, 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
-          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
-        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
-        end
-
-        def validate_bucket_name!(bucket_name)
-          unless S3BucketDns.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
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_bucket_dns.rb

@@ -1,86 +0,0 @@
-module Aws
-  module Plugins
-
-    # Amazon S3 requires DNS style addressing for buckets outside of
-    # the classic region when possible.
-    #
-    # @seahorse.client.option [Boolean] :force_path_style (false)
-    #   When set to `true`, the bucket name is always left in the
-    #   request URI and never moved to the host as a sub-domain.
-    #
-    class S3BucketDns < Seahorse::Client::Plugin
-
-      # When set to `false` DNS compatible bucket names are moved from
-      # the request URI path to the host as a subdomain, unless the request
-      # is using SSL and the bucket name contains a dot.
-      #
-      # When set to `true`, the bucket name is always forced to be part
-      # of the request URI path.  This will not work with buckets outside
-      # the classic region.
-      option(:force_path_style, false)
-
-      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 &&
-            S3BucketDns.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
-
-      class << self
-
-        # @param [String] bucket_name
-        # @param [Boolean] ssl
-        # @return [Boolean]
-        def dns_compatible?(bucket_name, ssl)
-          if valid_subdomain?(bucket_name)
-            bucket_name.match(/\./) && ssl ? false : true
-          else
-            false
-          end
-        end
-
-        private
-
-        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
-end

data/lib/aws-sdk-core/plugins/s3_bucket_name_restrictions.rb

@@ -1,21 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class S3BucketNameRestrictions < Seahorse::Client::Plugin
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if context.params.key?(:bucket) && context.params[:bucket].include?('/')
-            msg = ":bucket option must not contain a forward-slash (/)"
-            raise ArgumentError, msg
-          end
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler)
-
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_control_dns.rb

@@ -1,25 +0,0 @@
-module Aws
-  module Plugins
-    class S3ControlDns < Seahorse::Client::Plugin
-      def add_handlers(handlers, config)
-        handlers.add(Handler, step: :build, priority: 1)
-      end
-
-      class Handler < Seahorse::Client::Handler
-        def call(context)
-          if context.operation.endpoint_pattern.nil?
-            move_account_id_to_subdomain(context)
-          end
-          @handler.call(context)
-        end
-
-        private
-        def move_account_id_to_subdomain(context)
-          account_id = context.params[:account_id]
-          endpoint = context.http_request.endpoint
-          endpoint.host = "#{account_id}.#{endpoint.host}"
-        end
-      end
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_control_dualstack.rb

@@ -1,48 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class S3ControlDualstack < Seahorse::Client::Plugin
-      option(:use_dualstack_endpoint, false)
-
-        def add_handlers(handlers, config)
-          handlers.add(OptionHandler, step: :initialize)
-          handlers.add(DualstackHandler, step: :build, priority: 2)
-        end
-
-        # @api private
-        class OptionHandler < Seahorse::Client::Handler
-          def call(context)
-            dualstack = context.params.delete(:use_dualstack_endpoint)
-            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
-            dns_suffix = EndpointProvider.dns_suffix_for(region)
-            host = "s3-control.dualstack.#{region}.#{dns_suffix}"
-            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_dualstack_endpoint?(context)
-            context[:use_dualstack_endpoint]
-          end
-        end
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_control_signer.rb

@@ -1,53 +0,0 @@
-require 'set'
-
-module Aws
-  module Plugins
-    # This plugin is an implementation detail and may be modified.
-    # @api private
-    class S3ControlSigner < Seahorse::Client::Plugin
-
-      class SigningHandler < RequestSigner::Handler
-
-        def call(context)
-          require_credentials(context)
-          version = context.config.signature_version
-          apply_v4_signature(context)
-          @handler.call(context)
-        end
-
-        private
-
-        def apply_v4_signature(context)
-          Signers::V4.new(
-            context.config.credentials, 's3',
-            context[:cached_sigv4_region] || context.config.sigv4_region,
-          ).sign(context.http_request)
-        end
-
-        def apply_s3_legacy_signature(context)
-          Signers::S3.sign(context)
-        end
-
-      end
-
-      # Abstract base class for the other two handlers
-      class Handler < Seahorse::Client::Handler
-
-        private
-
-        def new_hostname(context, region)
-          bucket = context.params[:bucket]
-          if region == 'us-east-1'
-            "#{bucket}.s3.amazonaws.com"
-          else
-            bucket + '.' + URI.parse(EndpointProvider.resolve(region, 's3')).host
-          end
-        end
-
-      end
-
-      # sign the request
-      handler(SigningHandler, step: :sign)
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_dualstack.rb

@@ -1,67 +0,0 @@
-module Aws
-  module Plugins
-
-    # @api private
-    # @seahorse.client.option [Boolean] :use_dualstack_endpoint (false)
-    #   When set to `true`, IPv6-compatible bucket endpoints will be used
-    #   for all operations.
-    class S3Dualstack < Seahorse::Client::Plugin
-
-      option(:use_dualstack_endpoint, false)
-      option(:use_accelerate_endpoint, false)
-
-      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)
-          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
-          force_path_style = context.config.force_path_style
-          dns_suffix = 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 && S3BucketDns.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-core/plugins/s3_expect_100_continue.rb

@@ -1,27 +0,0 @@
-module Aws
-  module Plugins
-    class S3Expect100Continue < Seahorse::Client::Plugin
-
-      def add_handlers(handlers, config)
-        if config.http_continue_timeout && config.http_continue_timeout > 0
-          handlers.add(Handler)
-        end
-      end
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if
-            context.http_request.body &&
-            context.http_request.body.size > 0
-          then
-            context.http_request.headers['expect'] = '100-continue'
-          end
-          @handler.call(context)
-        end
-
-      end
-    end
-  end
-end

data/lib/aws-sdk-core/plugins/s3_get_bucket_location_fix.rb

@@ -1,21 +0,0 @@
-module Aws
-  module Plugins
-    class S3GetBucketLocationFix < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          @handler.call(context).on(200) do |response|
-            response.data = S3::Types::GetBucketLocationOutput.new
-            xml = context.http_response.body_contents
-            matches = xml.match(/>(.+?)<\/LocationConstraint>/)
-            response.data[:location_constraint] = matches ? matches[1] : ''
-          end
-        end
-      end
-
-      handler(Handler, priority: 60, operations: [:get_bucket_location])
-
-    end
-  end
-end