aws-sdk 1.7.1 → 1.8.0

data/lib/aws/core/managed_file.rb

@@ -0,0 +1,32 @@
+# 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
+
+    # This trival wrapper around File provides an easy way for the client to know when
+    # the file that it just streamed over HTTP should be closed after receiving the
+    # response.  This should only be used internally to track files that we opened.
+    # Open files passed into upload methods should be closed by the user.
+    # @private
+    class ManagedFile < File
+
+      def self.open path
+        file_opts = ['rb']
+        file_opts << { :encoding => "BINARY" } if Object.const_defined?(:Encoding)
+        super(path.to_s, *file_opts)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# 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'
+require 'base64'
+
+module AWS
+  module Core
+    module Options
+
+      # Given a hash of serialization rules, a JSONSerializer can convert
+      # a hash of request options into a JSON document.  The request options 
+      # are validated before returning JSON.
+      class JSONSerializer
+
+        # @param [Hash] rules A hash of option rules to validate against.
+        # @param [String,nil] payload_param
+        def initialize rules, payload_param
+          @payload_param = payload_param
+          @rules = @payload_param ? rules[@payload_param][:members] : 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
+
+        # @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
+          request_options = request_options[@payload_param] if @payload_param
+          data = normalize_keys(request_options, rules)
+          if rules.any?{|k,v| v[:location] == 'body' }
+            data = data.values.first
+          end
+          JSON.pretty_generate(data)
+        end
+
+        protected
+
+        def normalize_keys values, rules
+          values.inject({}) do |h,(k,v)|
+            child_rules = rules[k]
+            child_name = child_rules[:name] || Inflection.class_name(k.to_s)
+            h.merge(child_name => normalize_value(v, child_rules))
+          end
+        end
+
+        def normalize_value value, rules
+          case rules[:type]
+          when :hash then normalize_keys(value, rules[:members])
+          when :array then value.map{|v| normalize_value(v, rules[:members]) }
+          when :map
+            value.inject({}) do |h,(k,v)|
+              h.merge(k => normalize_value(v, rules[:members]))
+            end
+          when :blob then Base64.encode64(value.read).strip
+          else value
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -45,7 +45,7 @@ module AWS
           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}"
+                raise ArgumentError, "missing required option #{opt_name.inspect}"
               end
             end
           end
@@ -129,6 +129,10 @@ module AWS
           value.to_s
         end
 
+        def validate_blob rules, value, opt_name, context = nil
+          value
+        end
+
         def format_error description, opt_name, context
           context = context || "option :#{opt_name}"
           raise ArgumentError, "expected #{description} for #{context}"

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

@@ -25,10 +25,11 @@ module AWS
         # @param [String] namespace
         # @param [String] operation_name
         # @param [Hash] rules A hash of option rules to validate against.
-        def initialize namespace, operation_name, rules
+        def initialize namespace, operation_name, operation
           @namespace = namespace
           @operation_name = operation_name
-          @rules = rules
+          @rules = operation[:inputs]
+          @http = operation[:http]
           @validator = Validator.new(rules)
         end
 
@@ -41,6 +42,9 @@ module AWS
         # @return [Hash]
         attr_reader :rules
 
+        # @return [Hash,nil]
+        attr_reader :http
+
         # @return [Validator]
         attr_reader :validator
 
@@ -50,9 +54,19 @@ module AWS
         #   @return [String] Returns an string of the request parameters
         #     serialized into XML.
         def serialize request_options
+          if http && http[:request_payload]
+            payload = http[:request_payload]
+            root_node_name = rules[payload][:name]
+            params = request_options[payload]
+            rules = self.rules[payload][:members]
+          else
+            root_node_name = "#{operation_name}Request"
+            params = request_options
+            rules = self.rules
+          end
           xml = Nokogiri::XML::Builder.new
-          xml.send("#{operation_name}Request", :xmlns => namespace) do |xml|
-            hash_members_xml(request_options, rules, xml)
+          xml.send(root_node_name, :xmlns => namespace) do |xml|
+            hash_members_xml(params, rules, xml)
           end
           xml.doc.root.to_xml
         end

data/lib/aws/core/{rest_client.rb → rest_json_client.rb}

@@ -13,26 +13,25 @@
 
 module AWS
   module Core
-    class RESTClient < Core::Client
+    class RESTJSONClient < Core::Client
 
       protected
 
       def self.request_builder_for api_config, operation
-        RESTRequestBuilder.new(api_config[:namespace], operation)
+        Core::RESTRequestBuilder.new(operation, :format => :json)
       end
 
       def self.response_parser_for api_config, operation
-        RESTResponseParser.new(operation)
+        Core::RESTResponseParser.new(operation, :format => :json)
       end
 
       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]
+          json = (::JSON.load(body) rescue nil)
         then
-          [error[:code], error[:message]]
+          [json['code'], json['message']]
         end
       end
 

data/lib/aws/core/rest_request_builder.rb

@@ -19,43 +19,67 @@ module AWS
     class RESTRequestBuilder
 
       # @private
-      def initialize namespace, operation
+      def initialize operation, options = {}
 
         @http = operation[:http]
-
         @rules = operation[:inputs]
 
         @validator = Options::Validator.new(@rules)
 
-        @xml_serializer = Options::XMLSerializer.new(
-          namespace, operation[:name], @rules)
+        @serializer =
+          case options[:format]
+          when :xml
+            namespace = options[:xmlnamespace]
+            name = operation[:name]
+            Options::XMLSerializer.new(namespace, name, operation)
+          when :json
+            Options::JSONSerializer.new(@rules, @http[:request_payload])
+          else
+            raise ArgumentError, "unhandled format: #{options[:format]}"
+          end
 
       end
 
-      # Populates an http request object with params in the uri, headers,
-      # and body.
+      # Populates a Http::Request with the following:
+      # 
+      # * HTTP method
+      # * URI
+      # * headers
+      # * body
+      #
       # @param [Http::Request] request
-      # @param [Hash] request_options A hash of options to send with
-      #   the request.
+      #
+      # @param [Hash] request_options The hash of request options provided 
+      #   to the client request method.  This will be used to populate
+      #   the headers, uri and body.
+      #
       # @raise [ArgumentError] Raises ArgumentError when any of the
       #   request options are invalid (wrong type, missing, unknown, etc).
-      # @return [Http::Request]
-      def populate_request request, request_options
+      #
+      def populate_request request, params
+        params = @validator.validate!(params)
+        populate_method(request)
+        populate_uri(request, params)
+        populate_headers(request, params)
+        populate_body(request, params)
+      end
 
-        params = @validator.validate!(request_options)
+      protected
 
+      def populate_method request
         request.http_method = @http[:verb]
+      end
+
+      def populate_uri request, params
         request.uri = extract_uri(params)
+      end
+
+      def populate_headers request, params
         extract_headers(params).each_pair do |header_name, header_value|
           request.headers[header_name] = header_value
         end
-        request.body = build_body(params)
-        request
-
       end
 
-      protected
-
       # @param [Hash] params
       # @return [String]
       def extract_uri params
@@ -63,15 +87,15 @@ module AWS
         path, querystring = @http[:uri].split(/\?/)
 
         uri = path.gsub(/:\w+/) do |param_name|
-          unless param = params.delete(param_name[1..-1].to_sym)
-            msg = "missing required uri argument :#{param_name[1..-1]}"
-            raise ArgumentError, msg
+          if param = params.delete(param_name.sub(/^:/, '').to_sym)
+            UriEscape.escape(param)
+          else
+            raise ArgumentError, "missing required option #{param_name}"
           end
-          UriEscape.escape(param)
         end
 
         querystring_parts = []
-        querystring.to_s.split(/&/).each do |part|
+        querystring.to_s.split(/&|;/).each do |part|
           param_name = part.match(/:(\w+)/)[1]
           if param = params.delete(param_name.to_sym)
             param = UriEscape.escape(param)
@@ -91,28 +115,28 @@ module AWS
       # @return [Hash]
       def extract_headers params
         headers = {}
-        (@http[:request_headers] || {}).each_pair do |param_name,header_name|
-          if param_value = params.delete(param_name)
-            headers[header_name] = param_value
-          end
+        (@http[:request_headers] || {}).each_pair do |param,header|
+          headers[header] = params[param] if params.key?(param)
         end
         headers
       end
 
       # @param [Hash] params
       # @return [String,nil]
-      def build_body params
+      def populate_body request, params
         if params.empty?
-          nil
+          request.body = nil
+        elsif payload = streaming_param # streaming request
+          request.body_stream = params[payload]
+          request.headers['Content-Length'] = params[payload].size
         else
-          if
-            payload = @http[:request_payload] and
-            @rules[payload][:type] != :hash
-          then
-            params[payload]
-          else
-            @xml_serializer.serialize(params)
-          end
+          request.body = @serializer.serialize(params)
+        end
+      end
+
+      def streaming_param
+        if payload = @http[:request_payload]
+          @rules[payload][:type] == :blob ? payload : nil
         end
       end
 

data/lib/aws/core/rest_response_parser.rb

@@ -19,9 +19,14 @@ module AWS
     class RESTResponseParser
 
       # @private
-      def initialize operation
+      def initialize operation, options
         @http = operation[:http]
-        @parser = XML::Parser.new(operation[:outputs])
+        @parser =
+          case options[:format]
+          when :xml then XML::Parser.new(operation[:outputs])
+          when :json then Core::JSONParser.new(operation[:outputs])
+          else raise "unhandled format: #{options[:format].inspect}"
+          end
       end
 
       # Given a response object, this method extract and returns a
@@ -30,18 +35,22 @@ module AWS
       # @return [Hash]
       def extract_data response
 
-        # parse the response XML body
         data = @parser.parse(response.http_response.body)
 
         # extract headers and insert into response
         (@http[:response_headers] || {}).each_pair do |name,header_name|
-          data[name] = response.http_response.headers[header_name]
+          header = response.http_response.headers[header_name.downcase]
+          data[name] = [header].flatten.first
         end
 
         data
 
       end
 
+      def simulate
+        {}
+      end
+
     end
 
   end

data/lib/aws/core/rest_xml_client.rb

@@ -0,0 +1,47 @@
+# 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
+    # @since 1.8.0
+    class RESTXMLClient < Core::Client
+
+      protected
+
+      def self.request_builder_for api_config, operation
+        RESTRequestBuilder.new(operation,
+          :format => :xml,
+          :xmlnamespace => api_config[:namespace])
+      end
+
+      def self.response_parser_for api_config, operation
+        RESTResponseParser.new(operation, :format => :xml)
+      end
+
+      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
+
+    # @deprecated Use RESTXMLClient instead.
+    RESTClient = RESTXMLClient
+  end
+end