aws-sdk-core 2.4.0 → 3.53.0

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,92 +0,0 @@
-require 'uri'
-
-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

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

@@ -1,162 +0,0 @@
-require 'openssl'
-
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Boolean] :verify_checksums (true)
-    #   When `true` MD5 checksums will be computed for messages sent to
-    #   an SQS queue and matched against MD5 checksums returned by Amazon SQS.
-    #   `Aws::Errors::Checksum` errors are raised for cases where checksums do
-    #   not match.
-    class SQSMd5s < Seahorse::Client::Plugin
-      OPERATIONS_TO_VERIFY = [:send_message, :send_message_batch]
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-        def call(context)
-          @handler.call(context).on_success do |response|
-            case context.operation_name
-            when :send_message
-              validate_send_message(context, response)
-            when :send_message_batch
-              validate_send_message_batch(context, response)
-            end
-          end
-        end
-
-        private
-
-        TRANSPORT_TYPE_ENCODINGS = {
-          'String' => 1,
-          'Binary' => 2,
-          'Number' => 1
-        }
-
-        DATA_TYPE = /\A(String|Binary|Number)(\..+)?\z/
-
-        NORMALIZED_ENCODING = Encoding::UTF_8
-
-        def validate_send_message(context, response)
-          body = context.params[:message_body]
-          attributes = context.params[:message_attributes]
-          validate_single_message(body, attributes, response)
-        end
-
-        def validate_send_message_batch(context, response)
-          context.params[:entries].each do |entry|
-            id = entry[:id]
-            body = entry[:message_body]
-            attributes = entry[:message_attributes]
-            message_response = response.successful.select { |r| r.id == id }[0]
-            unless message_response.nil?
-              validate_single_message(body, attributes, message_response)
-            end
-          end
-        end
-
-        def validate_single_message(body, attributes, response)
-          validate_body(body, response)
-          validate_attributes(attributes, response) unless attributes.nil?
-        end
-
-        def validate_body(body, response)
-          calculated_md5 = md5_of_message_body(body)
-          returned_md5 = response.md5_of_message_body
-          if calculated_md5 != returned_md5
-            error_message =  mismatch_error_message(
-              'message body',
-              calculated_md5,
-              returned_md5,
-              response)
-            raise Aws::Errors::ChecksumError, error_message
-          end
-        end
-
-        def validate_attributes(attributes, response)
-          calculated_md5 = md5_of_message_attributes(attributes)
-          returned_md5 = response.md5_of_message_attributes
-          if returned_md5 != calculated_md5
-            error_message =  mismatch_error_message(
-              'message atributes',
-              calculated_md5,
-              returned_md5,
-              response)
-            raise Aws::Errors::ChecksumError, error_message
-          end
-        end
-
-        def md5_of_message_body(message_body)
-          OpenSSL::Digest::MD5.hexdigest(message_body)
-        end
-
-        def md5_of_message_attributes(message_attributes)
-          encoded = { }
-          message_attributes.each do |name, attribute|
-            name = name.to_s
-            encoded[name] = String.new
-            data_type_without_label = DATA_TYPE.match(attribute[:data_type])[1]
-            encoded[name] << encode_length_and_bytes(name) <<
-            encode_length_and_bytes(attribute[:data_type]) <<
-            [TRANSPORT_TYPE_ENCODINGS[data_type_without_label]].pack('C'.freeze)
-
-            if attribute[:string_value] != nil
-              encoded[name] << encode_length_and_string(attribute[:string_value])
-            elsif attribute[:binary_value] != nil
-              encoded[name] << encode_length_and_bytes(attribute[:binary_value])
-            end
-          end
-
-          buffer = encoded.keys.sort.reduce(String.new) do |string, name|
-            string << encoded[name]
-          end
-          OpenSSL::Digest::MD5.hexdigest(buffer)
-        end
-
-        def encode_length_and_string(string)
-          string = String.new(string)
-          string.encode!(NORMALIZED_ENCODING)
-          encode_length_and_bytes(string)
-        end
-
-        def encode_length_and_bytes(bytes)
-          [bytes.bytesize, bytes].pack('L>a*'.freeze)
-        end
-
-        def mismatch_error_message(section, local_md5, returned_md5, response)
-          m = "MD5 returned by SQS does not match " <<
-          "the calculation on the original request. ("
-
-          if response.respond_to?(:id) && !response.id.nil?
-            m << "Message ID: #{response.id}, "
-          end
-
-          m << "MD5 calculated by the #{section}: " <<
-          "'#{local_md5}', MD5 checksum returned: '#{returned_md5}')"
-        end
-      end
-
-      option(:verify_checksums) do |config|
-        # By default, we will disable checksum verification when response
-        # stubbing is enable. If a user decides to enable both features,
-        # then they will need to stub the MD5s in the response.
-        # See the spec/aws/sqs/client/verify_checksums_spec.rb for
-        # examples of how to do this.
-        if config.respond_to?(:stub_responses)
-          !config.stub_responses
-        else
-          config.verify_checksums
-        end
-      end
-
-      def add_handlers(handlers, config)
-        if config.verify_checksums
-          handlers.add(Handler, {
-            priority: 10 ,
-            step: :validate,
-            operations: SQSMd5s::OPERATIONS_TO_VERIFY
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class SQSQueueUrls < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if url = context.params[:queue_url]
-            update_region(context, url)
-            update_endpoint(context, url)
-          end
-          @handler.call(context)
-        end
-
-        def update_endpoint(context, url)
-          context.http_request.endpoint = url
-        end
-
-        def update_region(context, url)
-          if region = url.to_s.split('.')[1]
-            context.config = context.config.dup
-            context.config.region = region
-            context.config.sigv4_region = region
-          end
-        end
-
-      end
-
-      handler(Handler)
-
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Aws
-  module Plugins
-    # Extends the default read-timeout value 
-    class SWFReadTimeouts < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          context.config = context.config.dup
-          context.config.http_read_timeout = 90
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler, operations: [
-        :poll_for_activity_task,
-        :poll_for_decision_task,
-      ])
-
-    end
-  end
-end

data/lib/aws-sdk-core/rds.rb

@@ -1,8 +0,0 @@
-Aws.add_service(:RDS, {
-  api: "#{Aws::API_DIR}/rds/2014-10-31/api-2.json",
-  docs: "#{Aws::API_DIR}/rds/2014-10-31/docs-2.json",
-  examples: "#{Aws::API_DIR}/rds/2014-10-31/examples-1.json",
-  paginators: "#{Aws::API_DIR}/rds/2014-10-31/paginators-1.json",
-  resources: "#{Aws::API_DIR}/rds/2014-10-31/resources-1.json",
-  waiters: "#{Aws::API_DIR}/rds/2014-10-31/waiters-2.json",
-})

data/lib/aws-sdk-core/redshift.rb

@@ -1,7 +0,0 @@
-Aws.add_service(:Redshift, {
-  api: "#{Aws::API_DIR}/redshift/2012-12-01/api-2.json",
-  docs: "#{Aws::API_DIR}/redshift/2012-12-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/redshift/2012-12-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/redshift/2012-12-01/paginators-1.json",
-  waiters: "#{Aws::API_DIR}/redshift/2012-12-01/waiters-2.json",
-})

data/lib/aws-sdk-core/route53.rb

@@ -1,7 +0,0 @@
-Aws.add_service(:Route53, {
-  api: "#{Aws::API_DIR}/route53/2013-04-01/api-2.json",
-  docs: "#{Aws::API_DIR}/route53/2013-04-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/route53/2013-04-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/route53/2013-04-01/paginators-1.json",
-  waiters: "#{Aws::API_DIR}/route53/2013-04-01/waiters-2.json",
-})

data/lib/aws-sdk-core/route53domains.rb

@@ -1,5 +0,0 @@
-Aws.add_service(:Route53Domains, {
-  api: "#{Aws::API_DIR}/route53domains/2014-05-15/api-2.json",
-  docs: "#{Aws::API_DIR}/route53domains/2014-05-15/docs-2.json",
-  paginators: "#{Aws::API_DIR}/route53domains/2014-05-15/paginators-1.json",
-})

data/lib/aws-sdk-core/s3.rb

@@ -1,26 +0,0 @@
-Aws.add_service(:S3, {
-  api: "#{Aws::API_DIR}/s3/2006-03-01/api-2.json",
-  docs: "#{Aws::API_DIR}/s3/2006-03-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/s3/2006-03-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/s3/2006-03-01/paginators-1.json",
-  resources: "#{Aws::API_DIR}/s3/2006-03-01/resources-1.json",
-  waiters: "#{Aws::API_DIR}/s3/2006-03-01/waiters-2.json",
-})
-
-module Aws
-  module S3
-
-    autoload :Presigner, 'aws-sdk-core/s3/presigner'
-    autoload :BucketRegionCache, 'aws-sdk-core/s3/bucket_region_cache'
-
-    # A cache of discovered bucket regions. You can call `#bucket_added`
-    # on this to be notified when you must configure the proper region
-    # to access a bucket.
-    #
-    # This cache is considered an implementation detail.
-    #
-    # @api private
-    BUCKET_REGIONS = BucketRegionCache.new
-
-  end
-end

data/lib/aws-sdk-core/s3/bucket_region_cache.rb

@@ -1,75 +0,0 @@
-require 'thread'
-
-module Aws
-  module S3
-    class BucketRegionCache
-
-      def initialize
-        @regions = {}
-        @listeners = []
-        @mutex = Mutex.new
-      end
-
-      # Registers a block as a callback. This listener is called when a
-      # new bucket/region pair is added to the cache.
-      #
-      #     S3::BUCKET_REGIONS.bucket_added do |bucket_name, region_name|
-      #       # ...
-      #     end
-      #
-      # This happens when a request is made against the classic endpoint,
-      # "s3.amazonaws.com" and an error is returned requiring the request
-      # to be resent with Signature Version 4. At this point, multiple
-      # requests are made to discover the bucket region so that a v4
-      # signature can be generated.
-      #
-      # An application can register listeners here to avoid these extra
-      # requests in the future. By constructing an {S3::Client} with
-      # the proper region, a proper signature can be generated and redirects
-      # avoided.
-      # @return [void]
-      def bucket_added(&block)
-        if block
-          @mutex.synchronize { @listeners << block }
-        else
-          raise ArgumentError, 'missing required block'
-        end
-      end
-
-      # @param [String] bucket_name
-      # @return [String,nil] Returns the cached region for the named bucket.
-      #   Returns `nil` if the bucket is not in the cache.
-      # @api private
-      def [](bucket_name)
-        @mutex.synchronize { @regions[bucket_name] }
-      end
-
-      # Caches a bucket's region. Calling this method will trigger each
-      # of the {#bucket_added} listener callbacks.
-      # @param [String] bucket_name
-      # @param [String] region_name
-      # @return [void]
-      # @api private
-      def []=(bucket_name, region_name)
-        @mutex.synchronize do
-          @regions[bucket_name] = region_name
-          @listeners.each { |block| block.call(bucket_name, region_name) }
-        end
-      end
-
-      # @api private
-      def clear
-        @mutex.synchronize { @regions = {} }
-      end
-
-      # @return [Hash] Returns a hash of cached bucket names and region names.
-      def to_hash
-        @mutex.synchronize do
-          @regions.dup
-        end
-      end
-      alias to_h to_hash
-
-    end
-  end
-end