aws-sdk 1.5.8 → 1.6.0

data/lib/aws/core/inflection.rb

@@ -23,9 +23,9 @@ module AWS
 
           key.
             sub(/^.*:/, '').                          # strip namespace
-            gsub(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'). # split acronyms from words
-            scan(/[a-z]+|\d+|[A-Z0-9]+[a-z]*/).       # split remaining words
-            join('_').downcase                        # join parts _ and downcase
+            gsub(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'). # split acronyms
+            scan(/[a-z]+|\d+|[A-Z0-9]+[a-z]*/).       # split words
+            join('_').downcase                        # join parts
 
         end
 

data/lib/aws/core/json_client.rb

@@ -0,0 +1,106 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'json'
+
+module AWS
+  module Core
+
+    # = AWS::Core::Client::JSON
+    #
+    # Clients extend this module if the service they represent are
+    # AWS Query services that accept and return JSON.
+    #
+    module JSONClient
+
+      # Constructs the option grammars, one per service operation.
+      # @private
+      def self.extended base
+        base.send(:include, ErrorParser)
+        base.send(:define_grammars)
+      end
+
+      # @return [Hash<Symbol,OptionGrammar>] Returns a hash option
+      #   grammars.  Keys are method names (operations) and values are
+      #   request option grammars that convert a ruby hash of options
+      #   into a JSON document.
+      # @private
+      def option_grammars
+        @option_grammars ||= {}
+      end
+
+      protected
+
+      # Enumerates through the operations specified in the API
+      # configuration (yaml configuration file found in lib/api_config/)
+      # and defines one request method per operation.
+      def define_grammars
+        api_config[:operations].each do |op|
+          option_grammars[op[:method]] = OptionGrammar.customize(op[:inputs])
+        end
+      end
+
+      def define_client_method method_name, operation
+        add_client_request_method(method_name) do
+
+          configure_request do |request, options|
+
+            parser = self.class.option_grammars[method_name]
+            x_amz_target = self.class::TARGET_PREFIX + operation
+
+            request.headers["content-type"] = "application/x-amz-json-1.0"
+            request.headers["x-amz-target"] = x_amz_target
+            request.body = parser.to_json(options)
+
+          end
+
+          process_response do |response|
+            response_body = response.http_response.body
+            response_body = "{}" if response_body == ""
+            data = ::JSON.load(response_body)
+            MetaUtils.extend_method(response, :data) { data }
+          end
+
+          simulate_response do |response|
+            data = {}
+            MetaUtils.extend_method(response, :data) { data }
+          end
+
+        end
+      end
+
+      module ErrorParser
+
+        def extract_error_details response
+          if
+            response.http_response.status >= 300 and
+            body = response.http_response.body and
+            json = (::JSON.load(body) rescue nil) and
+            type = json["__type"] and
+            matches = type.match(/\#(.*)$/)
+          then
+            code = matches[1]
+            if code == 'RequestEntityTooLarge'
+              message = 'Request body must be less than 1 MB'
+            else
+              message = json['message']
+            end
+            [code, message]
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/core/option_grammar.rb

@@ -211,8 +211,17 @@ module AWS
             def apply(option, member_descriptors)
               super(option)
               member_option = option.member_option if option.respond_to?(:member_option)
+
+              # ignoring member name descriptors for lists, only useful for rest
+              descriptors = []
+              member_descriptors.each do |descriptor|
+                unless descriptor.is_a?(Hash) and descriptor[:member_name]
+                  descriptors << descriptor
+                end
+              end
+
               member_option ||= ListMember.new
-              member_option = member_option.extend_with_config(*member_descriptors)
+              member_option = member_option.extend_with_config(*descriptors)
               MetaUtils.extend_method(option, :member_option) { member_option }
             end
   

data/lib/aws/core/options/validator.rb

@@ -0,0 +1,140 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module Options
+
+      # Given a hash of validation rules, a validator validate request
+      # options.  Validations support:
+      #
+      # * rejecting unknown options
+      # * ensuring presence of required options
+      # * validating expected option types (e.g. hash, array, string,
+      #   integer, etc).
+      #
+      # After validating, a hash of request options is returned with
+      # with normalized values (with converted types).
+      class Validator
+
+        # @param [Hash] rules A hash of option rules to validate against.
+        def initialize rules
+          @rules = rules
+        end
+
+        # @return [Hash]
+        attr_reader :rules
+
+        # @overload validate!(request_options)
+        #   @param [Hash] request_options The hash of options to validate.
+        #   @raise [ArgumentError] Raised when the options do not validate.
+        #   @return [Hash]
+        def validate! request_options, rules = @rules
+
+          # Verify all required options are present.
+          rules.each_pair do |opt_name, opt_rules|
+            if opt_rules[:required]
+              unless request_options.key?(opt_name)
+                raise ArgumentError, "missing required option :#{opt_name}"
+              end
+            end
+          end
+
+          request_options.inject({}) do |options, (opt_name, value)|
+
+            # Ensure this is a valid/accepted option
+            unless rules.key?(opt_name)
+              raise ArgumentError, "unexpected option #{opt_name.inspect}"
+            end
+
+            # Validate and convert the value
+            valid_value = validate_value(rules[opt_name], value, opt_name)
+
+            options.merge(opt_name => valid_value)
+
+          end
+        end
+
+        protected
+
+        # Proxies calls to the correct validation method based on the
+        # rules[:type].
+        def validate_value *args
+          send("validate_#{args.first[:type]}", *args)
+        end
+
+        # Ensures the value is a hash and validates the hash context.
+        def validate_hash rules, value, opt_name, context = nil
+          unless value.respond_to?(:to_hash)
+            format_error('hash value', opt_name, context)
+          end
+          validate!(value.to_hash, rules[:members])
+        end
+
+        # Ensures the value is an array (or at least enumerable) and
+        # that the yielded values are valid.
+        def validate_array rules, value, opt_name, context = nil
+          unless value.respond_to?(:each)
+            format_error('enumerable value', opt_name, context)
+          end
+          values = []
+          value.each do |v|
+            context = "member #{values.size} of :#{opt_name}"
+            values << validate_value(rules[:members], v, opt_name, context)
+          end
+          values
+        end
+
+        # Ensures the value is a string.
+        def validate_string rules, value, opt_name, context = nil
+
+          unless value.respond_to?(:to_str)
+            format_error('string value', opt_name, context)
+          end
+
+          rules[:lstrip] ?
+            value.to_str.sub(/^#{rules[:lstrip]}/, '') :
+            value.to_str
+        end
+
+        # Ensures the value is a boolean.
+        def validate_boolean rules, value, opt_name, context = nil
+          unless [true, false].include?(value)
+            format_error('true or false', opt_name, context)
+          end
+          value
+        end
+
+        # Ensures the value is an integer.
+        def validate_integer rules, value, opt_name, context = nil
+          unless value.respond_to?(:to_int)
+            format_error('integer value', opt_name, context)
+          end
+          value.to_int
+        end
+
+        # Ensures the value is a timestamp.
+        def validate_timestamp rules, value, opt_name, context = nil
+          # TODO : add validation to timestamps values
+          value.to_s
+        end
+
+        def format_error description, opt_name, context
+          context = context || "option :#{opt_name}"
+          raise ArgumentError, "expected #{description} for #{context}"
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/core/options/xml_serializer.rb

@@ -0,0 +1,98 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'builder'
+
+module AWS
+  module Core
+    module Options
+
+      # Given a hash of serialization rules, an XMLSerializer can convert
+      # a hash of request options into XML.  The request options are
+      # validated before returning XML.
+      class XMLSerializer
+
+        # @param [String] namespace
+        # @param [String] operation_name
+        # @param [Hash] rules A hash of option rules to validate against.
+        def initialize namespace, operation_name, rules
+          @namespace = namespace
+          @operation_name = operation_name
+          @rules = rules
+          @validator = Validator.new(rules)
+        end
+
+        # @return [String] Returns the name of the API operation.
+        attr_reader :operation_name
+
+        # @return [String]
+        attr_reader :namespace
+
+        # @return [Hash]
+        attr_reader :rules
+
+        # @return [Validator]
+        attr_reader :validator
+
+        # @overload serialize!(request_options)
+        #   @param [Hash] request_options A hash of already validated
+        #     request options with normalized values.
+        #   @return [String] Returns an string of the request parameters
+        #     serialized into XML.
+        def serialize request_options
+          xml = []
+          builder = Builder::XmlMarkup.new(:target => xml, :indent => 2)
+          builder.tag!("#{operation_name}Request", :xmlns => namespace) do
+            request_options.each_pair do |opt_name, opt_value|
+              to_xml(builder, opt_name, rules[opt_name], opt_value)
+            end
+          end
+          xml.join
+        end
+
+        protected
+
+        # @param [Builder::XmlMarkup] builder An XML builder object that should
+        #   be used to build the xml.
+        # @param [String,Symbol] opt_name The name of the input option.
+        # @param [Hash] rules The hash to XML conversion rules.
+        # @param [Mixed] value
+        # @return [String] Returns an XML string.
+        def to_xml builder, opt_name, rules, value
+
+          xml_name = rules[:name]
+          xml_name ||= opt_name.is_a?(String) ?
+            opt_name : Inflection.class_name(opt_name.to_s)
+
+          case value
+          when Hash
+            builder.tag!(xml_name) do
+              value.each_pair do |m_name, m_value|
+                to_xml(builder, m_name, rules[:members][m_name], m_value)
+              end
+            end
+          when Array
+            builder.tag!(xml_name) do
+              value.each do |member_value|
+                to_xml(builder, 'member', rules[:members], member_value)
+              end
+            end
+          else builder.tag!(xml_name, value)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/core/query_client.rb

@@ -0,0 +1,131 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+#me Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+
+    # When a client class extends this module, its API configuration
+    # is parsed.  For each operation in the API configuration, one
+    # client method is added.
+    #
+    # Clients extending Query all have in common their method
+    # of serializing request (input) paramters and parsing response
+    # (output) XML.
+    #
+    module QueryClient
+
+      # @private
+      def self.extended base
+        base.send(:include, ErrorParser)
+        base.send(:define_parsers)
+      end
+
+      # @return [Hash<Symbol,OptionGrammar>] Returns a hash option
+      #   parsers.  Hash keys are client method names and hash
+      #   values are {OptionGrammar} objects.
+      # @private
+      def option_parsers
+        @option_parsers ||= {}
+      end
+
+      # @return [Hash<Symbol,XML::Parser>] Returns a hash of xml
+      #   parsers.  Hash keys are client method names and hash
+      #   values are {XML::Parser} objects.
+      # @private
+      def xml_parsers
+        @xml_parsers ||= {}
+      end
+
+      protected
+
+      # Enumerates through the operations specified in the API
+      # configuration (yaml configuration file found in lib/api_config/)
+      # and defines one request method per operation.
+      def define_parsers
+        api_config[:operations].each do |op|
+
+          method_name = op[:method]
+
+          option_parsers[method_name] = OptionGrammar.customize(op[:inputs])
+          xml_parsers[method_name] = XML::Parser.new(op[:outputs])
+
+        end
+      end
+
+      def define_client_method method_name, operation_name
+        add_client_request_method(method_name) do
+
+          configure_request do |request, options|
+
+            now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+            request.headers['Content-Type'] =
+              "application/x-www-form-urlencoded; charset=utf-8"
+
+            request.add_param 'Timestamp', now
+            request.add_param 'Version', self.class::API_VERSION
+            request.add_param 'Action', operation_name
+
+            parser = self.class.option_parsers[method_name]
+            parser.request_params(options).each do |param|
+              request.add_param(param)
+            end
+
+          end
+
+          process_response do |response|
+            parser = self.class.xml_parsers[method_name]
+            response.data = parser.parse(response.http_response.body)
+          end
+
+          simulate_response do |response|
+            parser = self.class.xml_parsers[method_name]
+            response.data = parser.simulate
+          end
+
+        end
+      end
+
+      module ErrorParser
+
+        protected
+
+        def extract_error_details response
+          if
+            response.http_response.status >= 300 and
+            body = response.http_response.body and
+            error = errors_module::GRAMMAR.parse(body) and
+            error[:code]
+          then
+            [error[:code], error[:message]]
+          end
+        end
+
+      end
+
+    end
+  end
+end