aws-sdk-core 2.3.23 → 3.89.1

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

@@ -1,73 +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)
-
-      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)
-          use_accelerate_endpoint(context) if context[:use_accelerate_endpoint]
-          @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 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 != '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_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

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

@@ -1,45 +0,0 @@
-module Aws
-  module Plugins
-
-    # A handful of Amazon S3 operations will respond with a 200 status
-    # code but will send an error in the response body. This plugin
-    # injects a handler that will parse 200 response bodies for potential
-    # errors, allowing them to be retried.
-    # @api private
-    class S3Http200Errors < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          @handler.call(context).on(200) do |response|
-            if error = check_for_error(context)
-              context.http_response.status_code = 500
-              response.data = nil
-              response.error = error
-            end
-          end
-        end
-
-        def check_for_error(context)
-          xml = context.http_response.body_contents
-          if xml.match(/<Error>/)
-            error_code = xml.match(/<Code>(.+?)<\/Code>/)[1]
-            error_message = xml.match(/<Message>(.+?)<\/Message>/)[1]
-            S3::Errors.error_class(error_code).new(context, error_message)
-          end
-        end
-
-      end
-
-      handler(Handler,
-        step: :sign,
-        operations: [
-          :complete_multipart_upload,
-          :copy_object,
-          :upload_part_copy,
-        ]
-      )
-
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module Aws
-  module Plugins
-
-    # When making calls to {S3::Client#create_bucket} outside the
-    # "classic" region, the bucket location constraint must be specified.
-    # This plugin auto populates the constraint to the configured region.
-    class S3LocationConstraint < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          unless context.config.region == 'us-east-1'
-            populate_location_constraint(context.params, context.config.region)
-          end
-          @handler.call(context)
-        end
-
-        private
-
-        def populate_location_constraint(params, region)
-          params[:create_bucket_configuration] ||= {}
-          params[:create_bucket_configuration][:location_constraint] ||= region
-        end
-
-      end
-
-      handler(Handler, step: :initialize, operations: [:create_bucket])
-
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'openssl'
-require 'base64'
-
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Boolean] :compute_checksums (true)
-    #   When `true` a MD5 checksum will be computed for every request that
-    #   sends a body.  When `false`, MD5 checksums will only be computed
-    #   for operations that require them.  Checksum errors returned by Amazon
-    #   S3 are automatically retried up to `:retry_limit` times.
-    class S3Md5s < Seahorse::Client::Plugin
-
-      # Amazon S3 requires these operations to have an MD5 checksum
-      REQUIRED_OPERATIONS = [
-        :delete_objects,
-        :put_bucket_cors,
-        :put_bucket_lifecycle,
-        :put_bucket_policy,
-        :put_bucket_tagging,
-      ]
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          body = context.http_request.body
-          if body.size > 0
-            context.http_request.headers['Content-Md5'] ||= Checksums.md5(body)
-          end
-          @handler.call(context)
-        end
-
-      end
-
-      option(:compute_checksums, true)
-
-      def add_handlers(handlers, config)
-        # priority set low to ensure md5 is computed AFTER the request is
-        # built but before it is signed
-        handlers.add(Handler, {
-          priority: 10,
-          step: :build,
-          operations: config.compute_checksums ? nil : REQUIRED_OPERATIONS,
-        })
-      end
-
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Boolean] :follow_redirects (true)
-    #   When `true`, this client will follow 307 redirects returned
-    #   by Amazon S3.
-    class S3Redirects < Seahorse::Client::Plugin
-
-      option(:follow_redirects, true)
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          response = @handler.call(context)
-          if context.http_response.status_code == 307
-            endpoint = context.http_response.headers['location']
-            context.http_request.endpoint = endpoint
-            context.http_response.body.truncate(0)
-            @handler.call(context)
-          else
-            response
-          end
-        end
-
-      end
-
-      def add_handlers(handlers, config)
-        if config.follow_redirects
-          # we want to re-trigger request signing
-          handlers.add(Handler, step: :sign, priority: 90)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,166 +0,0 @@
-require 'set'
-
-module Aws
-  module Plugins
-    # This plugin is an implementation detail and may be modified.
-    # @api private
-    class S3RequestSigner < Seahorse::Client::Plugin
-
-      option(:signature_version, 'v4')
-
-      class SigningHandler < RequestSigner::Handler
-
-        def call(context)
-          require_credentials(context)
-          version = context.config.signature_version
-          case version
-          when 'v4' then apply_v4_signature(context)
-          when 's3' then apply_s3_legacy_signature(context)
-          else
-            raise "unsupported signature version #{version.inspect}, valid"\
-              " options: 'v4' (default), 's3'"
-          end
-          @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
-
-      # This handler will update the http endpoint when the bucket region
-      # is known/cached.
-      class CachedBucketRegionHandler < Handler
-
-        def call(context)
-          if bucket = context.params[:bucket]
-            use_regional_endpoint_when_known(context, bucket)
-          end
-          @handler.call(context)
-        end
-
-        private
-
-        def use_regional_endpoint_when_known(context, bucket)
-          cached_region = S3::BUCKET_REGIONS[bucket]
-          if cached_region && cached_region != context.config.region
-            context.http_request.endpoint.host = new_hostname(context, cached_region)
-            context[:cached_sigv4_region] = cached_region
-            context[:cached_signature_version] = :v4
-          end
-        end
-
-      end
-
-      # This handler detects when a request fails because of a mismatched bucket
-      # region. It follows up by making a request to determine the correct
-      # region, then finally a version 4 signed request against the correct
-      # regional endpoint.
-      class BucketRegionErrorHandler < Handler
-
-        def call(context)
-          response = @handler.call(context)
-          handle_region_errors(response)
-        end
-
-        private
-
-        def handle_region_errors(response)
-          if wrong_sigv4_region?(response)
-            get_region_and_retry(response.context)
-          else
-            response
-          end
-        end
-
-        def get_region_and_retry(context)
-          actual_region = context.http_response.headers['x-amz-bucket-region']
-          actual_region ||= region_from_body(context.http_response.body_contents)
-          update_bucket_cache(context, actual_region)
-          log_warning(context, actual_region)
-          update_region_header(context, actual_region)
-          @handler.call(context)
-        end
-
-        def update_bucket_cache(context, actual_region)
-          S3::BUCKET_REGIONS[context.params[:bucket]] = actual_region
-        end
-
-        def wrong_sigv4_region?(resp)
-          resp.context.http_response.status_code == 400 &&
-          (
-            resp.context.http_response.headers['x-amz-bucket-region'] ||
-            resp.context.http_response.body_contents.match(/<Region>.+?<\/Region>/)
-          )
-        end
-
-        def update_region_header(context, region)
-          context.http_response.body.truncate(0)
-          context.http_request.headers.delete('authorization')
-          context.http_request.headers.delete('x-amz-security-token')
-          context.http_request.endpoint.host = new_hostname(context, region)
-          signer = Signers::V4.new(context.config.credentials, 's3', region)
-          signer.sign(context.http_request)
-        end
-
-        def region_from_body(body)
-          region = body.match(/<Region>(.+?)<\/Region>/)[1]
-          if region.nil? || region == ""
-            raise "couldn't get region from body: #{body}"
-          else
-            region
-          end
-        end
-
-        def log_warning(context, actual_region)
-          msg = "S3 client configured for #{context.config.region.inspect} " +
-            "but the bucket #{context.params[:bucket].inspect} is in " +
-            "#{actual_region.inspect}; Please configure the proper region " +
-            "to avoid multiple unnecessary redirects and signing attempts\n"
-          if logger = context.config.logger
-            logger.warn(msg)
-          else
-            warn(msg)
-          end
-        end
-
-      end
-
-      # BEFORE signing
-      handle(CachedBucketRegionHandler, step: :sign, priority: 60)
-
-      # sign the request
-      handler(SigningHandler, step: :sign)
-
-      # AFTER signing
-      handle(BucketRegionErrorHandler, step: :sign, priority: 40)
-
-    end
-  end
-end