aws-sdk-v1-reinteractive 1.67.1

data/lib/aws/core/resource_cache.rb

@@ -0,0 +1,40 @@
+# Copyright 2011-2013 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
+
+    # @api private
+    class ResourceCache
+
+      def initialize
+        @cache = {}
+      end
+
+      def store(key, attributes)
+        (@cache[key] ||= {}).merge!(attributes)
+      end
+
+      def cached?(key, attribute)
+        attributes = @cache[key] and attributes.has_key?(attribute)
+      end
+
+      def get(key, attribute)
+        raise "No cached value for attribute :#{attribute} of #{key}" unless
+          cached?(key, attribute)
+        @cache[key][attribute]
+      end
+
+    end
+  end
+end

data/lib/aws/core/response.rb

@@ -0,0 +1,215 @@
+# Copyright 2011-2013 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
+
+    # # Response
+    #
+    # Each Service has a Client class.  There is one method per service
+    # operation defined on the client.  These methods all return a {Response}
+    # object.
+    #
+    # In addition to the response data, these responses provide metadata
+    # about the HTTP request made and the HTTP response received.
+    #
+    # ## Response Data
+    #
+    # You can access the response data for a client request using the {#data}
+    # method or the {#[]} method.  Response data is a hash and {#[]} is
+    # a shortcut for accessing this hash.
+    #
+    #     # make a request to describe one instance
+    #     ec2 = AWS::EC2.new
+    #     response = ec2.client.describe_instances(:instance_ids => ['i-12345678'])
+    #
+    #     # find the instance in the response data (2 ways to get the data)
+    #     instance = response[:reservation_set].first[:instance_set].first
+    #     instance = response.data[:reservation_set].first[:instance_set].first
+    #
+    #     instance[:status] #=> 'running'
+    #
+    # ## Response Metadata
+    #
+    # In addition to the response data, there is additional information
+    # available with the response, including:
+    #
+    # * {#request_type} - the name of the client request method
+    # * {#request_options} - the hash of options passed to the client method
+    # * {#http_request} - The HTTP request made
+    # * {#http_response} - the HTTP response received
+    #
+    # Given the example and response object from above:
+    #
+    #     response.request_type #=> :describe_instances
+    #     response.request_options #=> { :instance_ids => ['i-12345678'] }
+    #     response.http_request #=> #<AWS::Core::Http::Request>
+    #     response.http_response #=> #<AWS::Core::Http::Response>
+    #
+    class Response
+
+      include AsyncHandle
+
+      # @return [Hash] Returns the response data as a hash.
+      attr_accessor :data
+
+      # @api private
+      attr_accessor :config
+
+      # @return [Symbol] The name of the client request method that
+      #   returned this response.
+      attr_accessor :request_type
+
+      # @return [String] The API version of the request/client.
+      attr_accessor :api_version
+
+      # @return [Hash] Returns the hash of options passed to the client
+      #   request method that generated this response.
+      attr_accessor :request_options
+
+      # @return [Core::Http::Request]
+      attr_accessor :http_request
+
+      # @return [Core::Http::Response]
+      attr_accessor :http_response
+
+      # @return [Boolean] true if the response was generated from a
+      #   another cached response.
+      attr_accessor :cached
+
+      alias_method :cached?, :cached
+
+      # @return [AWS::Error,nil] Returns nil unless the request failed.
+      #   Normally this will be nil unless you are using the Asynchronous
+      #   interface.
+      attr_accessor :error
+
+      # @return [Integer] Returns the number of times the request
+      #   was retried.
+      attr_accessor :retry_count
+
+      # @return [Float] The total number of seconds taken to make the
+      #   request and return the response.
+      attr_accessor :duration
+
+      # @param [Http::Request] http_request
+      # @param [Http::Response] http_response
+      def initialize http_request = nil, http_response = nil, &block
+        @http_request = http_request
+        @http_response = http_response
+        @request_builder = block
+        @data = {}
+        @retry_count = 0
+        @duration = 0
+        build_request if @request_builder && !http_request
+      end
+
+      # Provides access to the response data.  This is a short-cut
+      # for calling `response.data[key]`.
+      #
+      # @param [Symbol,String] key
+      # @return [Hash,nil]
+      def [] key
+        data[key]
+      end
+
+      # @return [Boolean] Returns true if there is no response error.
+      def successful?
+        error.nil?
+      end
+
+      # @return [Boolean] Returns `true` if the http request failed due to
+      #   a networking issue.
+      def network_error?
+        http_response.network_error?
+      end
+
+      # @return [String]
+      # @api private
+      def inspect
+        data.inspect
+      end
+
+      # @return [String]
+      # @api private
+      def cache_key
+        [
+          api_version,
+          http_request.access_key_id,
+          http_request.host,
+          request_type,
+          serialized_options
+        ].join(":")
+      end
+
+      # Rebuilds the HTTP request using the block passed to the initializer.
+      # This is primarily used by the client when a request must be retried
+      # (throttling, server errors, socket errors, etc).
+      # @api private
+      def rebuild_request
+        @http_request.body_stream.rewind if @http_request.body_stream
+        build_request
+      end
+
+      # @return [Boolean] Returns `false` if it is not safe to retry a
+      #   request.  This happens when the http request body is an IO
+      #   object that can not be rewound and re-streamed.
+      def safe_to_retry?
+        @http_request.body_stream.nil? or
+        @http_request.body_stream.respond_to?(:rewind)
+      end
+
+      protected
+
+      def build_request
+        @http_request = @request_builder.call
+      end
+
+      # @note The prefered method to get as response data is to use {#[]}.
+      #
+      # This provides a backwards-compat layer to the old response objects
+      # where each response value had a method extended onto this object.
+      # Now all response data is accessible as a hash.
+      #
+      # @see #[]
+      # @see #data
+      #
+      def method_missing *args, &block
+        Core::Data.new(data).send(*args, &block)
+      end
+
+      def serialized_options
+        serialize_options_hash(request_options)
+      end
+
+      def serialize_options_hash(hash)
+        "(" + hash.keys.sort_by(&:to_s).map do |key|
+          "#{key}=#{serialize_options_value(hash[key])}"
+        end.join(" ") + ")"
+      end
+
+      def serialize_options_value(value)
+        case value
+        when Hash  then serialize_options_hash(value)
+        when Array then serialize_options_array(value)
+        else value.inspect
+        end
+      end
+
+      def serialize_options_array array
+        "[" + array.map{|v| serialize_options_value(v) }.join(" ") + "]"
+      end
+
+    end
+  end
+end

data/lib/aws/core/response_cache.rb

@@ -0,0 +1,50 @@
+# Copyright 2011-2013 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
+
+    # @api private
+    class ResponseCache
+
+      attr_reader :cached_responses
+
+      attr_reader :resource_cache
+
+      def initialize
+        @cached_responses = []
+        @indexed_responses = {}
+        @resource_cache = ResourceCache.new
+      end
+
+      def add(resp)
+        cached_responses.unshift(resp)
+        @indexed_responses[resp.cache_key] = resp if
+          resp.respond_to?(:cache_key)
+        @resource_cache = ResourceCache.new
+      end
+
+      def select(*types, &block)
+        cached_responses.select do |resp|
+          types.map{|t| t.to_s }.include?(resp.request_type.to_s) and
+            (block.nil? || block.call(resp))
+        end
+      end
+
+      def cached(resp)
+        @indexed_responses[resp.cache_key]
+      end
+
+    end
+  end
+end

data/lib/aws/core/rest_error_parser.rb

@@ -0,0 +1,24 @@
+# Copyright 2011-2013 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
+
+    # @api private
+    module RESTErrorParser
+
+
+    end
+
+  end
+end

data/lib/aws/core/rest_json_client.rb

@@ -0,0 +1,40 @@
+# Copyright 2011-2013 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 RESTJSONClient < Core::Client
+
+      protected
+
+      def self.request_builder_for api_config, operation
+        Core::RESTRequestBuilder.new(operation, :format => :json)
+      end
+
+      def self.response_parser_for api_config, 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
+          json = (::JSON.load(body) rescue nil)
+        then
+          [json['code'], json['message']]
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/core/rest_request_builder.rb

@@ -0,0 +1,154 @@
+# Copyright 2011-2013 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
+
+    # Given a hash of request options, a REST::RequestHandler can
+    # populate a Core::Http::Request object.
+    class RESTRequestBuilder
+
+      # @api private
+      def initialize operation, options = {}
+
+        @http = operation[:http]
+        @rules = operation[:inputs]
+
+        @validator = Options::Validator.new(@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 a Http::Request with the following:
+      #
+      #   * HTTP method
+      #   * URI
+      #   * headers
+      #   * body
+      #
+      # @param [Http::Request] request
+      #
+      # @param [Hash] params 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).
+      #
+      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
+
+      private
+
+      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
+      end
+
+      # @param [Hash] params
+      # @return [String]
+      def extract_uri params
+
+        path, querystring = @http[:uri].split(/\?/)
+
+        uri = path.gsub(/:\w+/) do |param_name|
+          if param = params.delete(param_name.sub(/^:/, '').to_sym)
+            UriEscape.escape(param)
+          else
+            raise ArgumentError, "missing required option #{param_name}"
+          end
+        end
+
+        querystring_parts = []
+        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)
+            querystring_parts << part.sub(/:#{param_name}/, param)
+          end
+        end
+
+        unless querystring_parts.empty?
+          uri << "?#{querystring_parts.join('&')}"
+        end
+
+        uri
+
+      end
+
+      # @param [Hash] params
+      # @return [Hash]
+      def extract_headers params
+        headers = {}
+        (@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 populate_body request, params
+        if params.empty?
+          request.body = nil
+        elsif payload = streaming_param # streaming request
+          request.body_stream = params[payload]
+          request.headers['Content-Length'] = size(params[payload])
+        else
+          request.body = @serializer.serialize(params)
+        end
+      end
+
+      def size(payload)
+        if payload.respond_to?(:path) && payload.path
+          File.size(payload.path)
+        else
+          payload.size
+        end
+      end
+
+      def streaming_param
+        if payload = @http[:request_payload]
+          @rules[payload][:type] == :blob ? payload : nil
+        end
+      end
+
+    end
+
+  end
+end