aws-sdk-core 2.11.549

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

@@ -0,0 +1,20 @@
+module Aws
+  module Plugins
+    # @api private
+    class MachineLearningPredictEndpoint < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          endpoint = context.params.delete(:predict_endpoint)
+          context.http_request.endpoint = URI.parse(endpoint.to_s)
+          @handler.call(context)
+        end
+
+      end
+
+      handle(Handler, operations: [:predict])
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :convert_params (true)
+    #   When `true`, an attempt is made to coerce request parameters
+    #   into the required types.
+    class ParamConverter < Seahorse::Client::Plugin
+
+      option(:convert_params, true)
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, step: :initialize) if config.convert_params
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          converter = Aws::ParamConverter.new(context.operation.input)
+          context.params = converter.convert(context.params)
+          @handler.call(context).on_complete do |resp|
+            converter.close_opened_files
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :validate_params (true)
+    #   When `true`, request parameters are validated before
+    #   sending the request.
+    class ParamValidator < Seahorse::Client::Plugin
+
+      option(:validate_params, true)
+
+      def add_handlers(handlers, config)
+        if config.validate_params
+          handlers.add(Handler, step: :validate, priority: 50)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          Aws::ParamValidator.validate!(context.operation.input, context.params)
+          @handler.call(context)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/ec2.rb

@@ -0,0 +1,35 @@
+module Aws
+  module Plugins
+    module Protocols
+      class EC2 < Seahorse::Client::Plugin
+
+        class Handler < Aws::Query::Handler
+
+          def apply_params(param_list, params, rules)
+            Aws::Query::EC2ParamBuilder.new(param_list).apply(rules, params)
+          end
+
+          def parse_xml(context)
+            if rules = context.operation.output
+              parser = Xml::Parser.new(rules)
+              data = parser.parse(xml(context)) do |path, value|
+                if path.size == 2 && path.last == 'requestId'
+                  context.metadata[:request_id] = value
+                end
+              end
+              data
+            else
+              EmptyStructure.new
+            end
+          end
+
+        end
+
+        handler(Handler)
+
+        handler(Xml::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/json_rpc.rb

@@ -0,0 +1,30 @@
+module Aws
+  module Plugins
+    module Protocols
+
+      # @seahorse.client.option [Boolean] :simple_json (false)
+      #   Disables request parameter conversion, validation, and formatting.
+      #   Also disable response data type conversions. This option is useful
+      #   when you want to ensure the highest level of performance by
+      #   avoiding overhead of walking request parameters and response data
+      #   structures.
+      #
+      #   When `:simple_json` is enabled, the request parameters hash must
+      #   be formatted exactly as the DynamoDB API expects.
+      #
+      class JsonRpc < Seahorse::Client::Plugin
+
+        option(:simple_json, false)
+
+        option(:validate_params) { |config| !config.simple_json }
+
+        option(:convert_params) { |config| !config.simple_json }
+
+        handler(Json::Handler)
+
+        handler(Json::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/query.rb

@@ -0,0 +1,12 @@
+module Aws
+  module Plugins
+    module Protocols
+      class Query < Seahorse::Client::Plugin
+
+        handler(Aws::Query::Handler)
+        handler(Xml::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/rest_json.rb

@@ -0,0 +1,12 @@
+module Aws
+  module Plugins
+    module Protocols
+      class RestJson < Seahorse::Client::Plugin
+
+        handler(Rest::Handler)
+        handler(Json::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/rest_xml.rb

@@ -0,0 +1,12 @@
+module Aws
+  module Plugins
+    module Protocols
+      class RestXml < Seahorse::Client::Plugin
+
+        handler(Rest::Handler)
+        handler(Xml::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'aws-sigv4'
+
+module Aws
+  module Plugins
+
+    # This plugin populates the `:pre_signed_url` request param for the
+    # CopyDBSnapshot API.
+    #
+    # This parameter is required by RDS when copying an encrypted snapshot
+    # across regions. This plugin will be skipped if the `:pre_signed_url`
+    # parameter is provided by the user.
+    #
+    # @seahorse.client.option [String] :source_region The region which you are
+    #  copying an encrypted snapshot from. This parameter must be present to
+    #  have the plugin compute a presigned URL on your behalf.
+    class RDSCrossRegionCopying < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          params = context.params
+          if params[:source_region] && !params[:pre_signed_url]
+            params[:pre_signed_url] = presigned_url(context, params)
+            params[:destination_region] = context.config.region
+          end
+          @handler.call(context)
+        end
+
+        private
+        def presigned_url(context, params)
+          # :source_region is not modeled in the api
+          source_region = params.delete(:source_region)
+          param_list = Aws::Query::ParamList.new
+          param_list.set('Action', context.operation.name)
+          param_list.set('DestinationRegion', context.config.region)
+          param_list.set('Version', context.config.api.metadata['apiVersion'])
+          Aws::Query::ParamBuilder.new(param_list).apply(
+            context.operation.input,
+            params
+          )
+          signer = Aws::Sigv4::Signer.new(
+            service: 'rds',
+            region: source_region,
+            credentials_provider: context.config.credentials
+          )
+          url = Aws::EndpointProvider.resolve(signer.region, 'rds')
+          url += "?#{param_list.to_s}"
+          signer.presign_url(
+            http_method: 'GET',
+            url: url,
+            body: '',
+            expires_in: 3600
+          ).to_s
+        end
+      end
+      handler(
+        Handler,
+        step: :initialize,
+        operations: [
+          :copy_db_snapshot,
+          :create_db_instance_read_replica,
+          :copy_db_cluster_snapshot,
+          :create_db_cluster
+        ]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [required, String] :region
+    #   The AWS region to connect to.  The region is used to construct
+    #   the client endpoint.  Defaults to `ENV['AWS_REGION']`.
+    #   Also checks `AMAZON_REGION` and `AWS_DEFAULT_REGION`.
+    #
+    # @seahorse.client.option [String] :endpoint A default endpoint is
+    #   constructed from the `:region`.
+    #
+    class RegionalEndpoint < Seahorse::Client::Plugin
+
+      # raised when region is not configured
+      MISSING_REGION = 'missing required configuration option :region'
+
+      option(:profile)
+
+      option(:region) do |cfg|
+        resolve_region(cfg)
+      end
+
+      option(:regional_endpoint, false)
+
+      option(:endpoint) do |cfg|
+        endpoint_prefix = cfg.api.metadata['endpointPrefix']
+        if cfg.region && endpoint_prefix
+          if cfg.respond_to?(:sts_regional_endpoints)
+            sts_regional = cfg.sts_regional_endpoints
+          end
+          EndpointProvider.resolve(cfg.region, endpoint_prefix, sts_regional)
+        end
+      end
+
+      def after_initialize(client)
+        if client.config.region.nil? or client.config.region == ''
+          msg = "missing region; use :region option or "
+          msg << "export region name to ENV['AWS_REGION']"
+          raise Errors::MissingRegionError, msg
+        end
+      end
+
+      private
+
+      def self.resolve_region(cfg)
+        keys = %w(AWS_REGION AMAZON_REGION AWS_DEFAULT_REGION)
+        env_region = ENV.values_at(*keys).compact.first
+        env_region = nil if env_region == ''
+        cfg_region = Aws.shared_config.region(profile: cfg.profile)
+        env_region || cfg_region
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [required, Credentials] :credentials Your
+    #   AWS credentials.  The following locations will be searched in order
+    #   for credentials:
+    #
+    #   * `:access_key_id`, `:secret_access_key`, and `:session_token` options
+    #   * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
+    #   * `HOME/.aws/credentials` shared credentials file
+    #   * EC2 instance profile credentials
+    #
+    # @seahorse.client.option [String] :profile Used when loading credentials
+    #   from the shared credentials file at HOME/.aws/credentials.  When not
+    #   specified, 'default' is used.
+    #
+    # @seahorse.client.option [String] :access_key_id Used to set credentials
+    #   statically.
+    #
+    # @seahorse.client.option [String] :secret_access_key Used to set
+    #   credentials statically.
+    #
+    # @seahorse.client.option [String] :session_token Used to set credentials
+    #   statically.
+    #
+    class RequestSigner < Seahorse::Client::Plugin
+
+      option(:access_key_id)
+
+      option(:secret_access_key)
+
+      option(:session_token)
+
+      option(:profile)
+
+      option(:credentials) do |config|
+        CredentialProviderChain.new(config).resolve
+      end
+
+      option(:instance_profile_credentials_retries, 0)
+
+      option(:instance_profile_credentials_timeout, 1)
+
+      # Intentionally not documented - this should go away when all
+      # services support signature version 4 in every region.
+      option(:signature_version) do |cfg|
+        cfg.api.metadata['signatureVersion']
+      end
+
+      option(:sigv4_name) do |cfg|
+        cfg.api.metadata['signingName'] || cfg.api.metadata['endpointPrefix']
+      end
+
+      option(:sigv4_region) do |cfg|
+        prefix = cfg.api.metadata['endpointPrefix']
+        if prefix.nil?
+          cfg.region
+        elsif cfg.endpoint.to_s.match(/#{prefix}\.amazonaws\.com/)
+          'us-east-1'
+        else
+          cfg.region
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        SIGNERS = {
+          'v4'      => Signers::V4,
+          'v3https' => Signers::V3,
+          'v2'      => Signers::V2,
+          's3'      => Signers::S3,
+        }
+
+        STS_UNSIGNED_REQUESTS = Set.new(%w(
+          AssumeRoleWithSAML
+          AssumeRoleWithWebIdentity
+        ))
+
+        COGNITO_IDENTITY_UNSIGNED_REQUESTS = Set.new(%w(
+          GetCredentialsForIdentity
+          GetId
+          GetOpenIdToken
+          UnlinkIdentity
+        ))
+
+        def call(context)
+          sign_authenticated_requests(context) unless unsigned_request?(context)
+          @handler.call(context)
+        end
+
+        private
+
+        def sign_authenticated_requests(context)
+          require_credentials(context)
+          if signer = SIGNERS[context.config.signature_version]
+            require_credentials(context)
+            signer.sign(apply_authtype(context))
+          end
+        end
+
+        def require_credentials(context)
+          if missing_credentials?(context)
+            msg = 'unable to sign request without credentials set'
+            raise Errors::MissingCredentialsError, msg
+          end
+        end
+
+        def missing_credentials?(context)
+          context.config.credentials.nil? or
+          !context.config.credentials.set?
+        end
+
+        def unsigned_request?(context)
+          if context.config.api.metadata['endpointPrefix'] == 'sts'
+            STS_UNSIGNED_REQUESTS.include?(context.operation.name)
+          elsif context.config.api.metadata['endpointPrefix'] == 'cloudsearchdomain'
+            context.config.credentials.nil? || !context.config.credentials.set?
+          elsif context.config.api.metadata['endpointPrefix'] == 'cognito-identity'
+            COGNITO_IDENTITY_UNSIGNED_REQUESTS.include?(context.operation.name)
+          else
+            false
+          end
+        end
+
+        def apply_authtype(context)
+          if context.operation['authtype'].eql?('v4-unsigned-body') &&
+            context.http_request.endpoint.scheme.eql?('https')
+            context.http_request.headers['X-Amz-Content-Sha256'] = 'UNSIGNED-PAYLOAD'
+          end
+          context
+        end
+
+      end
+
+      def add_handlers(handlers, config)
+        # See the S3RequestSignerPlugin for Amazon S3 signature logic
+        unless config.sigv4_name == 's3'
+          operations = []
+          config.api.operation_names.each do |operation_name|
+            if config.api.operation(operation_name)['authtype'] != 'none'
+              operations << operation_name
+            end
+          end
+          handlers.add(Handler, step: :sign, operations: operations)
+        end
+      end
+
+    end
+  end
+end