aws-sdk-core 2.11.386 → 3.71.0

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

@@ -1,164 +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)
-          unless attributes.nil? || attributes.empty?
-            validate_attributes(attributes, response)
-          end
-        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 attributes',
-              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/sts_regional_endpoints.rb

@@ -1,30 +0,0 @@
-module Aws
-  module Plugins
-
-    class STSRegionalEndpoints < Seahorse::Client::Plugin
-
-      option(:sts_regional_endpoints,
-        default: 'legacy',
-        doc_type: String,
-        docstring: <<-DOCS) do |cfg|
-Passing in 'regional' to enable regional endpoint for STS for all supported
-regions (except 'aws-global'), defaults to 'legacy' mode, using global endpoint
-for legacy regions.
-      DOCS
-        resolve_sts_regional_endpoints(cfg)
-      end
-
-      private
-                                                                       
-      def self.resolve_sts_regional_endpoints(cfg)
-        env_mode = ENV['AWS_STS_REGIONAL_ENDPOINTS']
-        env_mode = nil if env_mode == ''
-        cfg_mode = Aws.shared_config.sts_regional_endpoints(
-          profile: cfg.profile)
-        env_mode || cfg_mode || 'legacy'
-      end
-
-    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/polly.rb

@@ -1,14 +0,0 @@
-Aws.add_service(:Polly, {
-  api: "#{Aws::API_DIR}/polly/2016-06-10/api-2.json",
-  docs: "#{Aws::API_DIR}/polly/2016-06-10/docs-2.json",
-  examples: "#{Aws::API_DIR}/polly/2016-06-10/examples-1.json",
-  paginators: "#{Aws::API_DIR}/polly/2016-06-10/paginators-1.json",
-})
-
-module Aws
-  module Polly
-
-    autoload :Presigner, 'aws-sdk-core/polly/presigner'
-
-  end
-end

data/lib/aws-sdk-core/polly/presigner.rb

@@ -1,70 +0,0 @@
-require 'aws-sigv4'
-
-module Aws
-  module Polly
-
-    # Allows you to create presigned URLs for `synthesize_speech`
-    #
-    # Example Use:
-    #
-    #   signer = Aws::Polly::Presigner.new
-    #   url = signer.synthesize_speech_presigned_url(
-    #     output_format: 'mp3',
-    #     text: 'Hello World',
-    #     voice_id: 'Ewa'
-    #   )
-    #
-    class Presigner
-
-      # @option options [required, Credentials] :credentials
-      #   You need provide an object that responds to `#credentials`
-      #   returning another object that responds to `#access_key_id`, `#secret_access_key`,
-      #   and `#session_token`.
-      #
-      #   For example, you could provide an instance of following classes:
-      #     * `Aws::Credentials`
-      #     * `Aws::SharedCredentials`
-      #     * `Aws::InstanceProfileCredentials`
-      #     * `Aws::AssumeRoleCredentials`
-      #     * `Aws::ECSCredentials`
-      #
-      # @option options [required, string] :region
-      #   The region name, e.g. 'us-west-2'
-      def initialize(options = {})
-        @credentials = options.fetch(:credentials)
-        @region = options.fetch(:region)
-      end
-
-      # @param [Hash] params parameter inputs for synthesize_speech operation
-      def synthesize_speech_presigned_url(params = {})
-        input_shape = Client.api.operation(:synthesize_speech).input.shape
-        sign_but_dont_send(input_shape, params)
-      end
-
-      private
-
-      def sign_but_dont_send(input_shape, params)
-        parts = []
-        input_shape.members.each do |name, ref|
-          parts << [ ref, params[name] ] unless params[name].nil?
-        end
-        query = Aws::Rest::Request::QuerystringBuilder.new.build(parts)
-
-        signer = Aws::Sigv4::Signer.new(
-          service: 'polly',
-          region: @region,
-          credentials_provider: @credentials
-        )
-        url = Aws::EndpointProvider.resolve(signer.region, 'polly')
-        url += "/v1/speech?#{query}"
-        pre_signed_url = signer.presign_url(
-          http_method: 'GET',
-          url: url,
-          body: '',
-          expires_in: 900
-        ).to_s
-      end
-    end
-
-  end
-end

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

@@ -1,6 +0,0 @@
-Aws.add_service(:Pricing, {
-  api: "#{Aws::API_DIR}/pricing/2017-10-15/api-2.json",
-  docs: "#{Aws::API_DIR}/pricing/2017-10-15/docs-2.json",
-  examples: "#{Aws::API_DIR}/pricing/2017-10-15/examples-1.json",
-  paginators: "#{Aws::API_DIR}/pricing/2017-10-15/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:QLDB, {
-  api: "#{Aws::API_DIR}/qldb/2019-01-02/api-2.json",
-  docs: "#{Aws::API_DIR}/qldb/2019-01-02/docs-2.json",
-  examples: "#{Aws::API_DIR}/qldb/2019-01-02/examples-1.json",
-  paginators: "#{Aws::API_DIR}/qldb/2019-01-02/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:QLDBSession, {
-  api: "#{Aws::API_DIR}/qldb-session/2019-07-11/api-2.json",
-  docs: "#{Aws::API_DIR}/qldb-session/2019-07-11/docs-2.json",
-  examples: "#{Aws::API_DIR}/qldb-session/2019-07-11/examples-1.json",
-  paginators: "#{Aws::API_DIR}/qldb-session/2019-07-11/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:QuickSight, {
-  api: "#{Aws::API_DIR}/quicksight/2018-04-01/api-2.json",
-  docs: "#{Aws::API_DIR}/quicksight/2018-04-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/quicksight/2018-04-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/quicksight/2018-04-01/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:RAM, {
-  api: "#{Aws::API_DIR}/ram/2018-01-04/api-2.json",
-  docs: "#{Aws::API_DIR}/ram/2018-01-04/docs-2.json",
-  examples: "#{Aws::API_DIR}/ram/2018-01-04/examples-1.json",
-  paginators: "#{Aws::API_DIR}/ram/2018-01-04/paginators-1.json",
-})

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

@@ -1,16 +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",
-})
-
-module Aws
-  module RDS
-
-    autoload :AuthTokenGenerator, 'aws-sdk-core/rds/auth_token_generator'
-
-  end
-end

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

@@ -1,63 +0,0 @@
-require 'aws-sigv4'
-
-module Aws
-  module RDS
-
-    # The utility class helps generate an auth token that supports database login
-    # It provides a method:
-    #
-    # * {#auth_token} - Computes a login token which is similar to
-    #   a presigned url
-    class AuthTokenGenerator
-
-      # @option options [required, Credentials] :credentials
-      # You need provide an object that responds to `#credentials`
-      # returning another object that responds to `#access_key_id`, `#secret_access_key`,
-      # and `#session_token`.
-      #
-      # For example, you could provide an instance of following classes:
-      # * `Aws::Credentials`
-      # * `Aws::SharedCredentials`
-      # * `Aws::InstanceProfileCredentials`
-      # * `Aws::AssumeRoleCredentials`
-      # * `Aws::ECSCredentials`
-      def initialize(options = {})
-        @credentials = options.fetch(:credentials)
-      end
-
-      # To create a auth login token, following parameters are required:
-      #
-      # @params [required, String] :region Region the databaseis located in
-      # @params [required, String] :endpoint Hostname of the database with port number
-      #   For example: my-instance.us-west-2.rds.amazonaws.com:3306
-      # @params [required, String] :user_name Username to login as
-      #
-      # @return [String]
-      def auth_token(params)
-        region = params.fetch(:region)
-        endpoint = params.fetch(:endpoint)
-        user_name = params.fetch(:user_name)
-
-        param_list = Aws::Query::ParamList.new
-        param_list.set('Action', 'connect')
-        param_list.set('DBUser', user_name)
-
-        signer = Aws::Sigv4::Signer.new(
-          service: 'rds-db',
-          region: region,
-          credentials_provider: @credentials
-        )
-        url = "https://" + endpoint + "/?#{param_list.to_s}"
-        presigned_url = signer.presign_url(
-          http_method: 'GET',
-          url: url,
-          body: '',
-          expires_in: 900
-        ).to_s
-        # Remove extra scheme for token
-        presigned_url[8..-1]
-      end
-
-    end
-  end
-end