aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/lib/seahorse/client/plugins/api.rb

@@ -0,0 +1,11 @@
+module Seahorse
+  module Client
+    module Plugins
+      class Api < Plugin
+
+        option(:api)
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/content_length.rb

@@ -0,0 +1,22 @@
+module Seahorse
+  module Client
+    module Plugins
+      class ContentLength < Plugin
+
+        # @api private
+        class Handler < Client::Handler
+
+          def call(context)
+            length = context.http_request.body.size
+            context.http_request.headers['Content-Length'] = length
+            @handler.call(context)
+          end
+
+        end
+
+        handler(Handler, step: :sign, proiority: 0)
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/endpoint.rb

@@ -0,0 +1,36 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # @seahorse.client.option [String] :endpoint
+      #    The HTTP or HTTPS endpoint to send requests to.
+      #    For example:
+      #
+      #        'example.com'
+      #        'http://example.com'
+      #        'https://example.com'
+      #        'http://example.com:123'
+      #
+      #    This must include the host.  It may also include the scheme and
+      #    port.  When the scheme is not set it defaults to `https`
+      #    or `http` based on the `:ssl_default` option.
+      #
+      # @seahorse.client.option [Boolean] :ssl_default (true)
+      #    When `true`, endpoints without a scheme are prefixed by `http://`.
+      #    When `false`, endpoints without a scheme are prefixed by `http://`.
+      #
+      class Endpoint < Plugin
+
+        option(:endpoint) { |config| config.api.endpoint }
+
+        option(:ssl_default, true)
+
+        handle_request(:EndpointHandler, priority: 90) do |context|
+          context.http_request.endpoint = Http::Endpoint.new(
+            context.config.endpoint, ssl_default: context.config.ssl_default)
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/json_simple.rb

@@ -0,0 +1,34 @@
+require 'multi_json'
+
+module Seahorse
+  module Client
+    module Plugins
+
+      # This plugin performs two trivial translations:
+      #
+      # * The request parameters are serialized as JSON for the request body
+      # * The response body is deserialized as JSON for the response data
+      #
+      # No attempt is made to extract errors from the HTTP response body.
+      # Parsing the response only happens for a successful response.
+      #
+      class JsonSimple < Plugin
+
+        # @api private
+        class Handler < Client::Handler
+
+          def call(context)
+            context.http_request.body = MultiJson.dump(context.params)
+            @handler.call(context).on_success do |resp|
+              resp.data = MultiJson.load(resp.http_response.body_contents)
+            end
+          end
+
+        end
+
+        handler(Handler)
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/logging.rb

@@ -0,0 +1,37 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # Enables logging for all requests.  This plugin allows you to configure
+      # your logging device, the log format and the level to log messages at.
+      #
+      # @see Logging::Formatter
+      #
+      # @seahorse.client.option [Logger] :logger (nil) The Logger instance
+      #   to send log messages to.  If this option is not set, logging
+      #   will be disabled.
+      #
+      # @seahorse.client.option [Symbol] :log_level (:info) The log level
+      #   to send messages to the logger at.
+      #
+      # @seahorse.client.option [Logging::LogFormatter] :log_formatter The log
+      #   formatter.  Defaults to {Seahorse::Client::Logging::Formatter.default}.
+      #
+      class Logging < Plugin
+
+        option(:logger, nil)
+
+        option(:log_level, :info)
+
+        option(:log_formatter, Client::Logging::Formatter.default)
+
+        def add_handlers(handlers, config)
+          if config.logger
+            handlers.add(Client::Logging::Handler, step: :validate)
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/net_http.rb

@@ -0,0 +1,26 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # @seahorse.client.option [String] :http_proxy
+      # @seahorse.client.option [Integer] :http_open_timeout (15)
+      # @seahorse.client.option [Integer] :http_read_timeout (60)
+      # @seahorse.client.option [Integer] :http_idle_timeout (5)
+      # @seahorse.client.option [Float] :http_continue_timeout (1)
+      # @seahorse.client.option [Boolean] :http_wire_trace (false)
+      # @seahorse.client.option [Logger] :logger (nil)
+      # @seahorse.client.option [Boolean] :ssl_verify_peer (true)
+      # @seahorse.client.option [String] :ssl_ca_bundle
+      # @seahorse.client.option [String] :ssl_ca_directory
+      class NetHttp < Plugin
+
+        Client::NetHttp::ConnectionPool::OPTIONS.each_pair do |name, default|
+          option(name, default)
+        end
+
+        handler(Client::NetHttp::Handler, step: :send)
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/operation_methods.rb

@@ -0,0 +1,48 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # Defines a helper method for each API operation that builds and
+      # sends the named request.
+      #
+      # # Helper Methods
+      #
+      # This plugin adds a helper method that lists the availalbe API
+      # operations.
+      #
+      #     client.operation_names
+      #     #=> [:api_operation_name1, :api_operation_name2, ...]
+      #
+      # Additionally, it adds a helper method for each operation.  This helper
+      # handles building and sending the appropriate {Request}.
+      #
+      #     # without OperationMethods plugin
+      #     req = client.build_request(:api_operation_name, request_params)
+      #     resp = req.send_request
+      #
+      #     # using the helper method defined by OperationMethods
+      #     resp = client.api_operation_name(request_params)
+      #
+      class OperationMethods < Plugin
+
+        def after_initialize(client)
+          unless client.respond_to?(:operation_names)
+            add_operation_helpers(client, client.config.api.operations.keys)
+          end
+        end
+
+        def add_operation_helpers(client, operations)
+          client.class.send(:define_method, :operation_names) { operations }
+          operations.each do |name|
+            client.class.send(:define_method, name) do |*args, &block|
+              params = args[0] || {}
+              send_options = args[1] || {}
+              build_request(name, params).send_request(send_options, &block)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/param_conversion.rb

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

data/vendor/seahorse/lib/seahorse/client/plugins/param_validation.rb

@@ -0,0 +1,30 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # @seahorse.client.option [Boolean] :validate_params (true)
+      #   When `true`, request parameters are validated before
+      #   sending the request.
+      class ParamValidation < 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 < Client::Handler
+
+          def call(context)
+            ParamValidator.validate!(context.operation.input, context.params)
+            @handler.call(context)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/raise_response_errors.rb

@@ -0,0 +1,29 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # @seahorse.client.option [Boolean] :raise_response_errors (true)
+      #   When `true`, response errors are raised.
+      class RaiseResponseErrors < Plugin
+
+        option(:raise_response_errors, true)
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            response = @handler.call(context)
+            raise response.error if response.error
+            response
+          end
+        end
+
+        def add_handlers(handlers, config)
+          if config.raise_response_errors
+            handlers.add(Handler, step: :validate, priority: 95)
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/plugins/restful_bindings.rb

@@ -0,0 +1,205 @@
+require 'cgi'
+
+module Seahorse
+  module Client
+    module Plugins
+      class RestfulBindings < Plugin
+
+        # @api private
+        class Handler < Client::Handler
+
+          def call(context)
+            build_request(context)
+            @handler.call(context).on_success do |response|
+              parse_response(response)
+            end
+          end
+
+          private
+
+          def build_request(context)
+            populate_method(context)
+            populate_path(context)
+            populate_headers(context)
+            populate_body(context)
+          end
+
+          def populate_method(context)
+            context.http_request.http_method = context.operation.http_method
+          end
+
+          def populate_path(context)
+            builder = UriPathBuilder.new(
+              context.operation.http_path,
+              context.operation.input.uri_members)
+            context.http_request.path = builder.path(context.params)
+          end
+
+          def populate_headers(context)
+            context.operation.input.header_members.each do |member_name, member|
+              value = context.params[member_name]
+              unless value.nil?
+                build_header(member, context.http_request.headers, value)
+              end
+            end
+          end
+
+          def populate_body(context)
+            input = context.operation.input
+            if input.raw_payload?
+              payload = context.params[input.payload]
+              context.http_request.body = payload unless payload.nil?
+            end
+          end
+
+          def build_header(rule, headers, value)
+            if map_shape?(rule)
+              build_header_map(rule, headers, value)
+            else
+              headers[rule.serialized_name] = serialize_header_value(rule, value)
+            end
+          end
+
+          def build_header_map(shape, headers, hash)
+            hash.each_pair do |suffix, value|
+              headers["#{shape.serialized_name}#{suffix}"] =
+                serialize_header_value(shape.members, value)
+            end
+          end
+
+          def serialize_header_value(shape, value)
+            case shape
+            when Model::Shapes::UnixTimestampShape then value.to_i.to_s
+            when Model::Shapes::Rfc822TimestampShape then value.utc.rfc822
+            when Model::Shapes::Iso8601TimestampShape then value.utc.iso8601
+            else value.to_s
+            end
+          end
+
+          def parse_response(response)
+            output = response.context.operation.output
+            response.data ||= Structure.new(output.members.keys)
+            extract_headers(response)
+            extract_body(response)
+          end
+
+          def extract_headers(response)
+            headers = response.http_response.headers
+            rules = response.context.operation.output.header_members
+            rules.each do |member_name, member|
+              response.data[member_name] = header_value(member, headers)
+            end
+          end
+
+          def header_value(shape, headers)
+            if map_shape?(shape)
+              header_map(shape, headers)
+            else
+              parse_header_value(shape, headers[shape.serialized_name])
+            end
+          end
+
+          def header_map(shape, headers)
+            hash = {}
+            headers.each do |header, value|
+              if match = header.match(/^#{shape.serialized_name}(.+)/)
+                hash[match[1]] = parse_header_value(shape.members, value)
+              end
+            end
+            hash
+          end
+
+          def parse_header_value(shape, value)
+            if value
+              case shape
+              when Model::Shapes::UnixTimestampShape then Time.at(value.to_i)
+              when Model::Shapes::TimestampShape then Time.parse(value)
+              when Model::Shapes::IntegerShape then value.to_i
+              when Model::Shapes::FloatShape then value.to_f
+              when Model::Shapes::BooleanShape then value == 'true'
+              else value
+              end
+            end
+          end
+
+          def extract_body(response)
+            output = response.context.operation.output
+            if output.raw_payload?
+              response.data[output.payload] = response.http_response.body
+            end
+          end
+
+          def map_shape?(shape)
+            shape.is_a?(Model::Shapes::MapShape)
+          end
+
+        end
+
+        handle(Handler, priority: 90)
+
+        # @api private
+        class UriPathBuilder
+
+          PLACEHOLDER_REGEX = /{\w+?}/
+
+          # @param [String] path_pattern
+          # @param [Hash<Model::Shapes::Shape>] rules
+          def initialize(path_pattern, rules)
+            @pattern = path_pattern
+            @rules = rules
+          end
+
+          # @param [Hash] params
+          # @return [String<URI path>]
+          def path(params)
+            path, querystring = @pattern.split('?')
+            path = escape_path_params(path, params)
+            if querystring
+              querystring = escape_querystring_params(querystring, params)
+              path = "#{path}?#{querystring}" unless querystring.empty?
+            end
+            path
+          end
+
+          private
+
+          def escape_path_params(path, params)
+            path.gsub(PLACEHOLDER_REGEX) do |placeholder|
+              param_value = params[param_name(placeholder)]
+              path_escape(param_value)
+            end
+          end
+
+          def escape_querystring_params(querystring, params)
+            parts = []
+            querystring.split('&').each do |part|
+              if match = part.match(PLACEHOLDER_REGEX)
+                placeholder = match[0]
+                param_value = params[param_name(placeholder)]
+                unless param_value.nil?
+                  parts << part.sub(placeholder, escape(param_value.to_s))
+                end
+              else
+                parts << part # querystring param has no substitution
+              end
+            end
+            parts.join('&')
+          end
+
+          def param_name(placeholder)
+            placeholder[1..-2].to_sym
+          end
+
+          def path_escape(value)
+            escape(value).gsub('%2F', '/')
+          end
+
+          def escape(string)
+            CGI::escape(string.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+          end
+
+        end
+      end
+    end
+  end
+end