aws-sdk-core 2.6.9 → 2.7.0

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

@@ -0,0 +1,5 @@
+Aws.add_service(:Pinpoint, {
+  api: "#{Aws::API_DIR}/pinpoint/2016-12-01/api-2.json",
+  docs: "#{Aws::API_DIR}/pinpoint/2016-12-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/pinpoint/2016-12-01/examples-1.json",
+})

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

@@ -1,3 +1,5 @@
+require 'aws-sigv4'
+
 module Aws
   module Plugins
 
@@ -16,66 +18,33 @@ module Aws
         def call(context)
           params = context.params
           params[:destination_region] = context.config.region
-          params[:presigned_url] = presigned_url(context.client, params)
+          params[:presigned_url] = presigned_url(context, params)
           @handler.call(context)
         end
 
         private
 
-        def presigned_url(client, params)
-          client = source_region_client(client, params)
-          client.handle(PresignHandler, step: :build, priority: 0)
-          client.handlers.remove(Handler)
-          client.copy_snapshot(params).data # presigned url
-        end
-
-        def source_region_client(client, params)
-          EC2::Client.new({
-            region: params[:source_region] || 'region',
-            credentials: client.config.credentials,
-          })
-        end
-
-      end
-
-      # This handler intentionally does NOT call the next handler in
-      # the stack.  It generates a presigned url from the request
-      # and returns it as the response data.
-      #
-      # Before signing:
-      #
-      # * The HTTP method is changed from POST to GET
-      # * The url-encoded body is moved to the querystring
-      #
-      # @api private
-      class PresignHandler < Seahorse::Client::Handler
-
-        def call(context)
-          convert_post_2_get(context)
-          Seahorse::Client::Response.new(
-            context: context,
-            data: presigned_url(context.http_request, context.config))
-        end
-
-        private
-
-        def convert_post_2_get(context)
-          context.http_request.http_method = 'GET'
-          context.http_request.endpoint = new_endpoint(context)
-          context.http_request.body = ''
-          context.http_request.headers.delete('Content-Type')
-        end
-
-        def new_endpoint(context)
-          body = context.http_request.body_contents
-          endpoint = context.http_request.endpoint
-          endpoint.query = body
-          endpoint
-        end
-
-        def presigned_url(http_request, config)
-          signer = Signers::V4.new(config.credentials, 'ec2', config.region)
-          signer.presigned_url(http_request, expires_in: 3600)
+        def presigned_url(context, params)
+          param_list = Aws::Query::ParamList.new
+          param_list.set('Action', 'CopySnapshot')
+          param_list.set('DestinationRegion', context.config.region)
+          param_list.set('Version', context.config.api.metadata['apiVersion'])
+          Aws::Query::EC2ParamBuilder.new(param_list).apply(context.operation.input, params)
+
+          signer = Aws::Sigv4::Signer.new(
+            service: 'ec2',
+            region: params[:source_region],
+            credentials_provider: context.config.credentials
+          )
+          url = Aws::EndpointProvider.resolve(signer.region, 'ec2')
+          url += "?#{param_list.to_s}"
+
+          signer.presign_url(
+            http_method: 'GET',
+            url: url,
+            body: '',
+            expires_in: 3600
+          ).to_s
         end
 
       end

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

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+module Aws
+  module Plugins
+
+    # Provides support for auto filling operation parameters
+    # that enabled with `idempotencyToken` trait  with random UUID v4
+    # when no value is provided
+    class IdempotencyToken < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        # @param [RequestContext] context
+        # @param [Response]
+        def call(context)
+          auto_fill(context.params, context.operation.input)
+          @handler.call(context)
+        end
+
+        private
+
+        def auto_fill(params, ref)
+          ref.shape.members.each do |name, member_ref|
+            if member_ref['idempotencyToken']
+              params[name] ||= SecureRandom.uuid
+            end
+          end
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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]
+      )
+    end
+  end
+end

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

@@ -37,6 +37,10 @@ module Aws
         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|

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

@@ -32,6 +32,7 @@ module Aws
           'ProvisionedThroughputExceededException', # dynamodb
           'RequestLimitExceeded',                   # ec2
           'BandwidthLimitExceeded',                 # cloud search
+          'LimitExceededException',                 # kinesis
         ])
 
         CHECKSUM_ERRORS = Set.new([

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

@@ -39,7 +39,7 @@ module Aws
           if
             bucket_name &&
             S3BucketDns.dns_compatible?(bucket_name, https?(endpoint)) &&
-            context.operation_name != 'get_bucket_location'
+            context.operation_name.to_s != 'get_bucket_location'
           then
             move_bucket_to_subdomain(bucket_name, endpoint)
           end

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

@@ -77,7 +77,7 @@ module Aws
           returned_md5 = response.md5_of_message_attributes
           if returned_md5 != calculated_md5
             error_message =  mismatch_error_message(
-              'message atributes',
+              'message attributes',
               calculated_md5,
               returned_md5,
               response)

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

@@ -0,0 +1,13 @@
+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",
+})
+
+module Aws
+  module Polly
+
+    autoload :Presigner, 'aws-sdk-core/polly/presigner'
+
+  end
+end

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

@@ -0,0 +1,70 @@
+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/rekognition.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:Rekognition, {
+  api: "#{Aws::API_DIR}/rekognition/2016-06-27/api-2.json",
+  docs: "#{Aws::API_DIR}/rekognition/2016-06-27/docs-2.json",
+  examples: "#{Aws::API_DIR}/rekognition/2016-06-27/examples-1.json",
+  paginators: "#{Aws::API_DIR}/rekognition/2016-06-27/paginators-1.json",
+})

data/lib/aws-sdk-core/rest/request/endpoint.rb

@@ -5,15 +5,13 @@ module Aws
     module Request
       class Endpoint
 
-        include Seahorse::Model::Shapes
-
         # @param [Seahorse::Model::Shapes::ShapeRef] rules
         # @param [String] request_uri_pattern
         def initialize(rules, request_uri_pattern)
           @rules = rules
           request_uri_pattern.split('?').tap do |path_part, query_part|
             @path_pattern = path_part
-            @query_pattern = query_part
+            @query_prefix = query_part
           end
         end
 
@@ -31,7 +29,7 @@ module Aws
 
         def apply_path_params(uri, params)
           path = uri.path.sub(/\/$/, '') + @path_pattern.split('?')[0]
-          uri.path = path.gsub(/{\w+\+?}/) do |placeholder|
+          uri.path = path.gsub(/{.+?}/) do |placeholder|
             param_value_for_placeholder(placeholder, params)
           end
         end
@@ -50,70 +48,17 @@ module Aws
         end
 
         def apply_querystring_params(uri, params)
-          parts = []
-          parts << @query_pattern if @query_pattern
-          @rules.shape.members.each do |member_name, member|
-            if member.location == 'querystring' && !params[member_name].nil?
-              case member.shape
-
-              # supported scalar types
-              when StringShape, BooleanShape, FloatShape, IntegerShape, StringShape
-                param_name = member.location_name
-                param_value = params[member_name]
-                parts << "#{param_name}=#{escape(param_value.to_s)}"
-
-              # map of strings or map of string-list
-              when MapShape
-                if StringShape === member.shape.value.shape
-                  parts += query_map_of_string(params[member_name])
-                elsif ListShape === member.shape.value.shape
-                  parts += query_map_of_string_list(params[member_name])
-                else
-                  msg = "only map of string and string list supported"
-                  raise NotImplementedError, msg
-                end
-
-              when ListShape
-                if StringShape === member.shape.member.shape
-                  parts += list_of_strings(member.location_name, params[member_name])
-                else
-                  msg = "Only list of strings supported, got "
-                  msg << member.shape.member.shape.class.name
-                  raise NotImplementedError, msg
-                end
-
-              # unsupported querystring shape
-              else
-                raise NotImplementedError
-              end
-
-            end
-          end
-          uri.query = parts.empty? ? nil : parts.join('&')
-        end
-
-        def query_map_of_string(hash)
-          list = []
-          hash.each_pair do |key, value|
-            list << "#{escape(key)}=#{escape(value)}"
-          end
-          list
-        end
-
-        def query_map_of_string_list(hash)
-          list = []
-          hash.each_pair do |key, values|
-            values.each do |value|
-              list << "#{escape(key)}=#{escape(value)}"
+          # collect params that are supposed to be part of the query string
+          parts = @rules.shape.members.inject([]) do |parts, (member_name, member_ref)|
+            if member_ref.location == 'querystring' && !params[member_name].nil?
+              parts << [member_ref, params[member_name]]
             end
+            parts
           end
-          list
-        end
-
-        def list_of_strings(name, values)
-          values.map do |value|
-            "#{name}=#{escape(value)}"
-          end
+          querystring = QuerystringBuilder.new.build(parts)
+          querystring = [@query_prefix, querystring == '' ? nil : querystring].compact.join('&')
+          querystring = nil if querystring == ''
+          uri.query = querystring
         end
 
         def escape(string)

data/lib/aws-sdk-core/rest/request/querystring_builder.rb

@@ -0,0 +1,90 @@
+module Aws
+  module Rest
+    module Request
+      class QuerystringBuilder
+
+        include Seahorse::Model::Shapes
+
+        # Provide shape references and param values:
+        #
+        #     [
+        #       [shape_ref1, 123],
+        #       [shape_ref2, "text"]
+        #     ]
+        #
+        # Returns a querystring:
+        #
+        #   "Count=123&Words=text"
+        #
+        # @param [Array<Array<Seahorse::Model::ShapeRef, Object>>] params An array of
+        #   model shape references and request parameter value pairs.
+        #
+        # @return [String] Returns a built querystring
+        def build(params)
+          params.map do |(shape_ref, param_value)|
+            build_part(shape_ref, param_value)
+          end.join('&')
+        end
+
+        private
+
+        def build_part(shape_ref, param_value)
+          case shape_ref.shape
+          # supported scalar types
+          when StringShape, BooleanShape, FloatShape, IntegerShape, StringShape
+            param_name = shape_ref.location_name
+            "#{param_name}=#{escape(param_value.to_s)}"
+          when MapShape
+            if StringShape === shape_ref.shape.value.shape
+              query_map_of_string(param_value)
+            elsif ListShape === shape_ref.shape.value.shape
+              query_map_of_string_list(param_value)
+            else
+              msg = "only map of string and string list supported"
+              raise NotImplementedError, msg
+            end
+          when ListShape
+            if StringShape === shape_ref.shape.member.shape
+              list_of_strings(shape_ref.location_name, param_value)
+            else
+              msg = "Only list of strings supported, got "
+              msg << shape_ref.shape.member.shape.class.name
+              raise NotImplementedError, msg
+            end
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def query_map_of_string(hash)
+          list = []
+          hash.each_pair do |key, value|
+            list << "#{escape(key)}=#{escape(value)}"
+          end
+          list
+        end
+
+        def query_map_of_string_list(hash)
+          list = []
+          hash.each_pair do |key, values|
+            values.each do |value|
+              list << "#{escape(key)}=#{escape(value)}"
+            end
+          end
+          list
+        end
+
+        def list_of_strings(name, values)
+          values.map do |value|
+            "#{name}=#{escape(value)}"
+          end
+        end
+
+        def escape(string)
+          Seahorse::Util.uri_escape(string)
+        end
+
+      end
+    end
+  end
+end