aws-sdk 1.4.1 → 1.5.0

data/lib/aws/core/client/query_json.rb

@@ -0,0 +1,110 @@
+# 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
+    class Client
+
+      # 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 QueryJSON all have in common their method of
+      # serializing request (input) parameters and parsing response
+      # (output) JSON.
+      #
+      module QueryJSON
+          
+        def self.extended base
+          base.send(:include, ErrorParser)
+          base.send(:define_client_methods)
+        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
+  
+        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_client_methods
+          api_config[:operations].each do |op|
+  
+            method_name = op[:method]
+  
+            option_parsers[method_name] = 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_parsers[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
+end

data/lib/aws/core/client/query_xml.rb

@@ -0,0 +1,122 @@
+# 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
+    class Client
+
+      # 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 QueryXML all have in common their method
+      # of serializing request (input) paramters and parsing response
+      # (output) XML.
+      #
+      module QueryXML
+        
+        # @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.http_method = 'POST'
+              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
+end
+

data/lib/aws/core/data.rb

@@ -0,0 +1,242 @@
+# 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
+    
+    # Data is a light wrapper around a Ruby hash that provides
+    # method missing access to the hash contents.
+    #
+    # == Method Missing Access
+    #
+    # You can access hash content with methods if their keys
+    # are symbols.
+    #
+    #   data = AWS::Core::Data.new({ :a => 1, :b => 2, :c => true })
+    #   data.a #=> 1
+    #   data.b #=> 2
+    #   data.c #=> true
+    #   data.d #=> raises NoMethodError
+    #
+    # == Boolean Methods
+    #
+    # Given the structure above you can also use question-mark methods.
+    #
+    #   data.c? #=> true
+    #   data.d? #=> raises NoMethodError
+    #
+    # == Nested Hashes
+    #
+    # If the data contains nested hashes you can chain methods into
+    # the structure.
+    #
+    #   data = AWS::Core::Data.new(:a => { :b => { :c => 'abc' }})
+    #   data.a.b.c #=> 'abc'
+    #
+    # == Nested Arrays
+    #
+    # Arrays are wrapped in {Data::List} objects.  They ensure any
+    # data returned is correctly wrapped so you can continue using
+    # method-missing access.
+    #
+    #   data = AWS::Core::Data.new(
+    #    :people => [
+    #      {:name => 'john'},
+    #      {:name => 'jane'},
+    #   ]})
+    #
+    #   data.people[0].name #=> 'john'
+    #   data.people[1].name #=> 'jane'
+    #
+    #   data.people.map(&:name) #=> ['john','jane']
+    #
+    class Data
+
+      module MethodMissingProxy
+
+        # @private
+        def id
+          self[:id] || self.id  
+        end
+
+        def [] index_or_key
+          Data.cast(@data[index_or_key])
+        end
+
+        # @return [Boolean] Returns true if the passed object equals
+        #   the wrapped array.
+        def eql? other
+          if other.is_a?(MethodMissingProxy)
+            @data == other._data
+          else
+            @data == other
+          end
+        end
+        alias_method :==, :eql?
+
+        protected
+
+        def method_missing *args, &block
+          if block_given?
+            return_value = @data.send(*args) do |*values|
+              yield(*values.flatten.map{|v| Data.cast(v) })
+            end
+            Data.cast(return_value)
+          else
+            Data.cast(@data.send(*args))
+          end
+        end
+
+        def _data
+          @data
+        end
+
+      end
+
+      include MethodMissingProxy
+
+      def method_missing method_name, *args, &block
+        if 
+          args.empty? and !block_given? and
+          key = _remove_question_mark(method_name) and
+          @data.has_key?(key)
+        then
+          Data.cast(@data[key])
+        else
+          super
+        end
+      end
+      
+      # @param [Hash] data The ruby hash of data you need wrapped.
+      def initialize data
+        @data = data
+      end
+
+      # @return [Hash] Returns contents of this Data object as a raw hash.
+      def to_hash
+        @data
+      end
+      alias_method :to_h, :to_hash
+
+      # @return [Array]
+      def to_a
+        @data.to_a
+      end
+      alias_method :to_ary, :to_a
+
+      # @param [String,Symbol] method_name
+      # @return [Boolean] Returns true if this data object will
+      #   respond to the given method name.
+      def respond_to? method_name
+        @data.key?(_remove_question_mark(method_name)) or
+          @data.respond_to?(method_name)
+      end
+
+      # Returns an inspection string from the wrapped data.
+      #
+      #   data = AWS::Core::Data.new({ :a => 1, :b => 2, :c => true })
+      #   data.inspect #=> '{:a=>1, :b=>2, :c=>true}'
+      #
+      # @return [String]
+      #
+      def inspect
+        @data.inspect
+      end
+
+      # @private
+      def kind_of? klass
+        if klass == Hash
+          true
+        else
+          super
+        end
+      end
+      alias_method :is_a?, :kind_of?
+
+      protected
+
+      def _remove_question_mark method_name
+        case method_name
+        when Symbol then method_name.to_s.sub(/\?$/, '').to_sym
+        when String then method_name.sub(/\?$/, '')
+        else method_name
+        end
+      end
+
+      class << self
+        
+        # Given a hash, this method returns a {Data} object.  Given
+        # an Array, this method returns a {Data::List} object.  Everything
+        # else is returned as is.
+        #
+        # @param [Object] value The value to conditionally wrap.
+        #
+        # @return [Data,Data::List,Object] Wraps hashes and lists with 
+        #   Data and List objects, all other objects are returned as
+        #   is.
+        #
+        def cast value
+          case value
+          when Hash then Data.new(value)
+          when Array then Data::List.new(value)
+          else value
+          end
+        end
+
+      end
+
+      class List
+
+        include MethodMissingProxy
+        
+        # @param [Array] array
+        def initialize array
+          @data = array
+        end
+
+        # @return [String] Returns the inspection string for the
+        #   wrapped array.
+        def inspect
+          @data.inspect
+        end
+
+        # @return [Array] Returns the contents of this Data::List as
+        #   a raw array.
+        def to_ary
+          @data
+        end
+        alias_method :to_a, :to_ary
+
+        # #inject works on Core::Data::List in in 1.8.7 and 1.9.3, but not 
+        # in 1.9.2 unless we define it like so.
+        # @private
+        def inject *args, &block
+          @data.inject(*args) do |obj,value|
+            yield(Data.cast(obj),Data.cast(value))
+          end
+        end
+
+        # @private
+        def kind_of? klass
+          if klass == Array
+            true
+          else
+            super
+          end
+        end
+        alias_method :is_a?, :kind_of?
+
+      end
+    end
+  end
+end