aws-sdk-core 2.11.366 → 3.64.0

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

@@ -1,26 +0,0 @@
-module Aws
-  module Plugins
-
-    # Support S3 host id, more information, see:
-    # http://docs.aws.amazon.com/AmazonS3/latest/dev/troubleshooting.html#sdk-request-ids
-    #
-    # This plugin adds :host_id for s3 responses when available
-    # @api private
-    class S3HostId < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          response = @handler.call(context)
-          h = context.http_response.headers
-          context[:s3_host_id] = h['x-amz-id-2']
-          response
-        end
-
-      end
-
-      handler(Handler, step: :sign)
-
-    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

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

@@ -1,64 +0,0 @@
-require 'uri'
-require 'openssl'
-
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Boolean] :require_https_for_sse_cpk (true)
-    #   When `true`, the endpoint **must** be HTTPS for all operations
-    #   where server-side-encryption is used with customer-provided keys.
-    #   This should only be disabled for local testing.
-    class S3SseCpk < Seahorse::Client::Plugin
-
-      option(:require_https_for_sse_cpk, true)
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          compute_key_md5(context)
-          @handler.call(context)
-        end
-
-        private
-
-        def compute_key_md5(context)
-          params = context.params
-          if key = params[:sse_customer_key]
-            require_https(context)
-            params[:sse_customer_key] = base64(key)
-            params[:sse_customer_key_md5] = base64(md5(key))
-          end
-          if key = params[:copy_source_sse_customer_key]
-            require_https(context)
-            params[:copy_source_sse_customer_key] = base64(key)
-            params[:copy_source_sse_customer_key_md5] = base64(md5(key))
-          end
-        end
-
-        def require_https(context)
-          unless URI::HTTPS === context.config.endpoint
-            msg = <<-MSG.strip.gsub("\n", ' ')
-              Attempting to send customer-provided-keys for S3
-              server-side-encryption over HTTP; Please configure a HTTPS
-              endpoint. If you are attempting to use a test endpoint,
-              you can disable this check via `:require_https_for_sse_cpk`
-            MSG
-            raise ArgumentError, msg
-          end
-        end
-
-        def md5(str)
-          OpenSSL::Digest::MD5.digest(str)
-        end
-
-        def base64(str)
-          Base64.encode64(str).strip
-        end
-
-      end
-
-      handler(Handler, step: :initialize)
-
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-require 'uri'
-require 'cgi'
-
-module Aws
-  module Plugins
-
-    # This plugin auto-populates the `:encoding_type` request parameter
-    # to all calls made to Amazon S3 that accept it.
-    #
-    # This enables Amazon S3 to return object keys that might contain
-    # invalid XML characters as URL encoded strings.  This plugin also
-    # automatically decodes these keys so that the key management is
-    # transparent to the user.
-    #
-    # If you specify the `:encoding_type` parameter, then this plugin
-    # will be disabled, and you will need to decode the keys yourself.
-    #
-    # The following operations are managed:
-    #
-    # * {S3::Client#list_objects}
-    # * {S3::Client#list_multipart_uploads}
-    # * {S3::Client#list_object_versions}
-    #
-    class S3UrlEncodedKeys < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if context.params.key?(:encoding_type)
-            @handler.call(context) # user managed
-          else
-            manage_keys(context)
-          end
-        end
-
-        private
-
-        def manage_keys(context)
-          context.params[:encoding_type] = 'url'
-          @handler.call(context).on_success do |resp|
-            send("decode_#{resp.context.operation_name}_keys", resp.data)
-          end
-        end
-
-        def decode_list_objects_keys(data)
-          decode(:marker, data)
-          decode(:next_marker, data)
-          decode(:prefix, data)
-          decode(:delimiter, data)
-          data.contents.each { |o| decode(:key, o) } if data.contents
-          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
-        end
-
-        def decode_list_object_versions_keys(data)
-          decode(:key_marker, data)
-          decode(:next_key_marker, data)
-          decode(:prefix, data)
-          decode(:delimiter, data)
-          data.versions.each { |o| decode(:key, o) } if data.versions
-          data.delete_markers.each { |o| decode(:key, o) } if data.delete_markers
-          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
-        end
-
-        def decode_list_multipart_uploads_keys(data)
-          decode(:key_marker, data)
-          decode(:next_key_marker, data)
-          decode(:prefix, data)
-          decode(:delimiter, data)
-          data.uploads.each { |o| decode(:key, o) } if data.uploads
-          data.common_prefixes.each { |o| decode(:prefix, o) } if data.common_prefixes
-        end
-
-        def decode(member, struct)
-          if struct[member]
-            struct[member] = CGI.unescape(struct[member])
-          end
-        end
-
-      end
-
-      handler(Handler,
-        step: :validate,
-        priority: 0,
-        operations: [
-          :list_objects,
-          :list_object_versions,
-          :list_multipart_uploads,
-        ]
-      )
-
-    end
-  end
-end