aws-sdk-core 2.0.0.rc1

data/lib/aws/query/param_list.rb

@@ -0,0 +1,91 @@
+require 'stringio'
+
+module Aws
+  module Query
+    class ParamList
+
+      include Enumerable
+
+      # @api private
+      def initialize
+        @params = {}
+      end
+
+      # @param [String] param_name
+      # @param [String, nil] param_value
+      # @return [Param]
+      def set(param_name, param_value = nil)
+        param = Param.new(param_name, param_value)
+        @params[param.name] = param
+        param
+      end
+      alias []= set
+
+      # @return [Param, nil]
+      def [](param_name)
+        @params[param_name.to_s]
+      end
+
+      # @param [String] param_name
+      # @return [Param, nil]
+      def delete(param_name)
+        @params.delete(param_name)
+      end
+
+      # @return [Enumerable]
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      # @return [Boolean]
+      def empty?
+        @params.empty?
+      end
+
+      # @return [Array<Param>] Returns an array of sorted {Param} objects.
+      def to_a
+        @params.values.sort
+      end
+
+      # @return [String]
+      def to_s
+        to_a.map(&:to_s).join('&')
+      end
+
+      # @return [#read, #rewind, #size]
+      def to_io
+        IoWrapper.new(self)
+      end
+
+      # @api private
+      class IoWrapper
+
+        # @param [ParamList] param_list
+        def initialize(param_list)
+          @param_list = param_list
+          @io = StringIO.new(param_list.to_s)
+        end
+
+        # @return [ParamList]
+        attr_reader :param_list
+
+        # @return [Integer]
+        def size
+          @io.size
+        end
+
+        # @return [void]
+        def rewind
+          @io.rewind
+        end
+
+        # @return [String, nil]
+        def read(bytes = nil, output_buffer = nil)
+          @io.read(bytes, output_buffer)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/query/serializer.rb

@@ -0,0 +1,24 @@
+module Aws
+  module Query
+    # @api private
+    class Serializer
+
+      def setup_request(context)
+        context.http_request.headers['Content-Type'] =
+          'application/x-www-form-urlencoded; charset=utf-8'
+        finalize_param_list(context, Query::ParamList.new)
+      end
+
+      def serialize_params(context, rules, params)
+        finalize_param_list(context, Builder.to_query_params(rules, params))
+      end
+
+      def finalize_param_list(context, param_list)
+        param_list.set('Version', context.config.api.version)
+        param_list.set('Action', context.operation.name)
+        context.http_request.body = param_list.to_io
+      end
+
+    end
+  end
+end

data/lib/aws/request_handler.rb

@@ -0,0 +1,39 @@
+module Aws
+  # @api private
+  class RequestHandler
+
+    def initialize(serializer)
+      @serializer = serializer
+    end
+
+    attr_accessor :handler
+
+    def call(context)
+      setup_request(context)
+      serialize_params(context) if serialize_params?(context)
+      @handler.call(context)
+    end
+
+    def setup_request(context)
+      @serializer.setup_request(context)
+    end
+
+    def serialize_params(context)
+      input = context.operation.input
+      if input.payload
+        rules = input.payload_member
+        params = context.params[input.payload] || {}
+      else
+        rules = input
+        params = context.params
+      end
+      @serializer.serialize_params(context, rules, params)
+    end
+
+    def serialize_params?(context)
+      rules = context.operation.input
+      !(rules.raw_payload? || rules.payload_member.empty?)
+    end
+
+  end
+end

data/lib/aws/response_handler.rb

@@ -0,0 +1,38 @@
+module Aws
+  # @api private
+  class ResponseHandler
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    attr_accessor :handler
+
+    def call(context)
+      @handler.call(context).on_success do |response|
+        rules = context.operation.output
+        response.error = nil
+        response.data = case
+          when rules.raw_payload? then empty_struct(rules)
+          when rules.payload then parse_payload(rules, context)
+          else parse(rules, context)
+        end
+      end
+    end
+
+    def empty_struct(rules)
+      Structure.new(rules.members.keys)
+    end
+
+    def parse_payload(rules, context)
+      data = empty_struct(rules)
+      data[rules.payload] = parse(rules.payload_member, context)
+      data
+    end
+
+    def parse(rules, context)
+      @parser.parse(rules, context.http_response.body_contents)
+    end
+
+  end
+end

data/lib/aws/service.rb

@@ -0,0 +1,237 @@
+require 'multi_json'
+
+module Aws
+  class Service
+    class << self
+
+      # Constructs and returns versioned API client.  Defaults to the 
+      # newest/latest API version.
+      #
+      #     Aws::DynamoDB.new
+      #     #=> #<Aws::DynamoDB::V20120810>
+      #
+      # ## Specify API Version
+      #
+      # You can specify the API version and get a different client.
+      #
+      #     Aws::DynamoDB.new(api_version: '2011-12-05')
+      #     #=> #<Aws::DynamoDB::V20111205>
+      #
+      # ## Locking API Versions
+      #
+      # You can lock the API version for a service via {Aws.config}:
+      #
+      #     Aws.config[:dynamodb] = { api_version: '2011-12-05' }
+      #     Aws::DynamoDB.new
+      #     #=> #<Aws::DynamoDB::V20111205>
+      #
+      # ## Global Version Lock
+      #
+      # It is possible to provide a single 'YYYY-MM-DD' date to lock the
+      # API version for every service.  This is useful to ensure that
+      # future API updates do not break existing usage.
+      #
+      # When using the single lock, the API version that was current
+      # at the given date will be used.
+      #
+      # For example, Aws::DynamoDB has two API versions, 2011-12-05 and
+      # 2012-10-01.  If the lock date is in between these two dates, the
+      # older will be used.
+      #
+      #     Aws.config[:api_version] = '2012-01-01'
+      #     Aws::DynamoDB.new
+      #     #=> #<Aws::DynamoDB::V20111205>
+      #
+      # @return [Seahorse::Client::Base] Returns a versioned client.
+      def new(options = {})
+        options = options.dup
+        api_version = options.delete(:api_version) || default_api_version
+        versioned_client_class(api_version).new(options)
+      end
+
+      # Registers a new API version for this client factory.  You need to
+      # provide the API version in `YYYY-MM-DD` format and an API.
+      # The `api` may be a string path to an API on disk or a fully
+      # constructed `Seahorse::Model::Api` object.
+      #
+      # @example Register a versioned client with a path to the JSON api.
+      #   Aws::S3::add_version('2013-01-02', '/path/to/api/src.json')
+      #
+      # @example Register a versioned client with a hydrated API.
+      #   api = Seahorse::Model::Api.from_hash(api_src)
+      #   Aws::S3::add_version('2013-01-02', api)
+      #
+      # @param [String<YYYY-MM-DD>] api_version
+      # @param [String<Pathname>, Seahorse::Model::Api] api
+      # @return [void]
+      # @see .api_versions
+      # @see .default_api_version
+      # @see .latest_api_version
+      # @see .versioned_clients
+      def add_version(api_version, api)
+        apis[api_version] = api
+      end
+
+      # @return [Array<String>] Returns a list of supported API versions
+      #   in a `YYYY-MM-DD` format.
+      # @see .add_version
+      # @see .latest_api_version
+      # @see .default_api_version
+      # @see .default_client_class
+      # @see .versioned_clients
+      def api_versions
+        apis.keys.sort
+      end
+
+      # @return [String<YYYY-MM-DD>] Returns the most current API version.
+      # @see .add_version
+      # @see .api_versions
+      # @see .default_api_version
+      # @see .default_client_class
+      # @see .versioned_clients
+      def latest_api_version
+        api_versions.last
+      end
+
+      # @return [String<YYYY-MM-DD>] Returns the default API version.  This
+      #   is the version of the client that will be constructed if there
+      #   is other configured or specified API version.
+      # @see .add_version
+      # @see .api_versions
+      # @see .default_client_class
+      # @see .latest_api_version
+      # @see .versioned_clients
+      def default_api_version
+        svc_locked_version || aws_locked_version || latest_api_version
+      end
+
+      # Returns an array of versioned client classes for this service.
+      #
+      #     Aws::DynamoDB.versioned_clients
+      #     #=> [Aws::DynamoDB::V20111205, Aws::DynamoDB::V20120810]
+      #
+      # @return [Array<Class>] Returns an array of the versioned client
+      #   classes for this service.
+      # @see .add_version
+      # @see .api_versions
+      # @see .default_api_version
+      # @see .default_client_class
+      # @see .latest_api_version
+      def versioned_clients
+        api_versions.map { |api_version| versioned_client_class(api_version) }
+      end
+
+      # @return [Class<Seahorse::Client::Base>]
+      # @see .add_version
+      # @see .api_versions
+      # @see .default_api_version
+      # @see .latest_api_version
+      # @see .versioned_clients
+      def default_client_class
+        versioned_client_class(default_api_version)
+      end
+
+      # Adds a plugin to each versioned client class.
+      # @param [Plugin] plugin
+      # @return [void]
+      # @see .remove_plugin
+      def add_plugin(plugin)
+        versioned_clients.each do |client_class|
+          client_class.add_plugin(plugin)
+        end
+      end
+
+      # Removes a plugin from each versioned client class.
+      # @param [Plugin] plugin
+      # @return [void]
+      # @see .add_plugin
+      def remove_plugin(plugin)
+        versioned_clients.each do |client_class|
+          client_class.remove_plugin(plugin)
+        end
+      end
+
+      # @return [Symbol] Returns the service identifier.  This is the
+      #   downcased service name (e.g. `:s3`, `:dynamodb`, `:ec2`, etc).
+      attr_accessor :identifier
+
+      # @param [Symbol] identifier The downcased short name for this service.
+      # @param [Array<Api, String>] apis An array of client APIs for this
+      #   service.  Values may be string paths to API files or instances of
+      #   `Seahorse::Model::Api`.
+      # @return [Class<Service>]
+      # @api private
+      def define(identifier, apis = [])
+        klass = Class.new(self)
+        klass.const_set(:Errors, Module.new { extend Errors::DynamicErrors })
+        klass.identifier = identifier.to_sym
+        apis.each do |api|
+          if api.is_a?(String)
+            yyyy_mm_dd = api.match(/\d{4}-\d{2}-\d{2}/)[0]
+            klass.add_version(yyyy_mm_dd, api)
+          else
+            klass.add_version(api.version, api)
+          end
+        end
+        klass
+      end
+
+      private
+
+      def svc_locked_version
+        (Aws.config[identifier] || {})[:api_version]
+      end
+
+      def aws_locked_version
+        if api_version = Aws.config[:api_version]
+          api_versions.select { |v| v <= api_version }.last || api_version
+        end
+      end
+
+      def versioned_client_class(api_version)
+        const_get("V#{api_version.gsub('-', '')}")
+      end
+
+      def apis
+        @apis ||= {}
+      end
+
+      def const_missing(constant)
+        if constant =~ /^V\d{8}$/
+          api = api(api_version(constant))
+          const_set(constant, Seahorse::Client.define(api: api))
+        else
+          super
+        end
+      end
+
+      def api(api_version)
+        api = apis[api_version]
+        case api
+        when Seahorse::Model::Api then api
+        when String then load_api(api)
+        else
+          msg = "API #{api_version} not defined for #{name}"
+          raise Errors::NoSuchApiVersionError, msg
+        end
+      end
+
+      def api_version(constant)
+        yyyy = constant[1,4]
+        mm = constant[5,2]
+        dd = constant[7,2]
+        [yyyy, mm, dd].join('-')
+      end
+
+      def load_api(path)
+        api = MultiJson.load(File.read(path), max_nesting: false)
+        if api.key?('metadata')
+          Seahorse::Model::Api.from_hash(api)
+        else
+          Api::Translator.translate(api, documentation: false, errors: false)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/signers/base.rb

@@ -0,0 +1,29 @@
+module Aws
+  module Signers
+    class Base
+
+      # @param [Credentials] credentials
+      def initialize(credentials)
+        @credentials = credentials
+      end
+
+      private
+
+      def sha256_hmac(value)
+        Base64.encode64(
+          OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'),
+            @credentials.secret_access_key, value)
+        ).strip
+      end
+
+      class << self
+
+        # @param [Seahorse::Client::RequestContext] context
+        def sign(context)
+          new(context.config.credentials).sign(context.http_request)
+        end
+
+      end
+    end
+  end
+end