aws-sdk 1.1.3 → 1.1.4

data/lib/aws/resource.rb

@@ -1,381 +0,0 @@
-
-# Copyright 2011 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 'aws/model'
-require 'aws/cacheable'
-
-module AWS
-
-  # @private
-  class Resource
-
-    include Model
-    include Cacheable
-
-    # @private
-    class NotFound < StandardError; end
-
-    def initialize *args
-
-      super
-
-      # cache static attributes passed into options
-
-      options = args.last.is_a?(Hash) ? args.last : {}
-      options.each_pair do |opt_name,opt_value|
-        if 
-          self.class.attributes.has_key?(opt_name) and
-          self.class.attributes[opt_name].static?
-        then
-          static_attributes[opt_name] = opt_value
-        end
-      end
-
-    end
-
-    # @return [String] Returns a simple string representation of this resource.
-    def inspect
-
-      identifiers = []
-      resource_identifiers.each do |key, value|
-        if attr = self.class.attributes.values.find{|a| a.get_as == key }
-          identifiers << "#{attr.name}:#{value}"
-        else
-          identifiers << "#{key}:#{value}"
-        end
-      end
-
-      "<#{self::class} #{identifiers.join(' ')}>"
-
-    end
-
-    # @return [Boolean] Returns true if the objects references the same
-    #   AWS resource.
-    def == other
-      other.kind_of?(self.class) and 
-        resource_identifiers == other.resource_identifiers
-    end
-
-    alias_method :eql?, :==
-
-    # @private
-    protected
-    def get_resource attr_name
-      raise NotImplementedError
-    end
-
-    # @private
-    protected
-    def update_resource attr, value
-      raise NotImplementedError
-    end
-
-    # Overide this method is subclasses of Resource.  This method should 
-    # return an array of identifying key/value pairs.
-    #
-    #   # @private
-    #   protected
-    #   def resource_identifiers
-    #     [[:user_name, name]]
-    #   end
-    # 
-    # @private
-    protected
-    def resource_identifiers
-      raise NotImplementedError
-    end
-
-    # @protected
-    protected
-    def resource_options(additional = {})
-      Hash[resource_identifiers].merge(additional)
-    end
-
-    # @private
-    protected
-    def local_cache_key
-      resource_identifiers.collect{|name,value| value.to_s }.join(":")
-    end
-
-    # @private
-    protected
-    def static_attributes
-      @static_attributes ||= {}
-    end
-
-    # @private
-    protected
-    def ruby_name
-      @ruby_name ||= Inflection.ruby_name(self.class.name)
-    end
-
-    # @private
-    public
-    def attributes_from_response resp
-
-      attributes = {}
-
-      self.class.attribute_providers_for(resp.request_type).each do |provider|
-        attributes.merge!(provider.attributes_from_response(self, resp))
-      end
-
-      # cache static attributes
-      attributes.each do |attr_name,value|
-        if self.class.attributes[attr_name].static?
-          static_attributes[attr_name] = value
-        end
-      end
-
-      attributes.empty? ? nil : attributes
-
-    end
-
-    # @private
-    protected
-    def cache_static_attributes request_type, resp_obj
-      self.class.attribute_providers_for(request_type).each do |provider|
-        attributes = provider.attributes_from_response_object(resp_obj)
-        attributes.each_pair do |attr_name,value|
-          if self.class.attributes[attr_name].static?
-            static_attributes[attr_name] = value
-          end
-        end
-      end
-    end
-
-
-    class << self
-
-      # @private
-      def new_from request_type, resp_obj, *args
-        resource = new(*args)  
-        resource.send(:cache_static_attributes, request_type, resp_obj)
-        resource
-      end
-
-      # @private
-      def attributes
-        @attributes ||= Hash.new do |hash,attr_name|
-          raise "uknown attribute #{attr_name}"
-        end
-      end
-
-      # @private
-      def attribute_providers
-        @attribute_providers ||= []
-      end
-
-      # @private
-      def attribute_providers_for request_type
-        attribute_providers.select do |provider|
-          provider.request_types.include?(request_type)
-        end
-      end
-
-      # @private
-      protected
-      def attribute name, options = {}, &block
-        attr = Attribute.new(name, options)
-        attr.instance_eval(&block) if block_given?
-        define_attribute_getter(attr)
-        define_attribute_setter(attr) if attr.mutable?
-        attributes[attr.name] = attr
-      end
-
-      # @private
-      protected
-      def mutable_attribute name, options = {}, &block
-        attribute(name, options.merge(:mutable => true), &block)
-      end
-
-      # @private
-      protected
-      def define_attribute_getter attribute
-        define_method(attribute.name) do
-          
-          return static_attributes[attribute.name] if 
-            static_attributes.has_key?(attribute.name)
-
-          begin
-            retrieve_attribute(attribute) { get_resource(attribute) }
-          rescue Cacheable::NoData => e
-            name = ruby_name.tr("_", " ")
-            raise NotFound, "unable to find the #{name}"
-          end
-
-        end
-      end
-
-      # @private
-      protected
-      def define_attribute_setter attribute
-        setter = attribute.name.to_s.sub(/\?/, '') + '='
-        define_method(setter) do |value|
-          translated_value = attribute.translate_input_value(value)
-          update_resource(attribute, translated_value)
-          if attribute.static?
-            static_attributes[attribute.name] = translated_value
-          end
-          value
-        end
-      end
-
-      # @private
-      protected
-      def populates_from *request_types, &block
-        provider = provider(*request_types)
-        provider.find(&block)
-        provider.provides(*attributes.keys)
-        provider
-      end
-
-      # @private
-      protected
-      def provider *request_types, &block
-        provider = AttributeProvider.new(self, request_types)
-        if block_given?
-          yield(provider)
-        end
-        attribute_providers << provider 
-        provider
-      end
-
-    end
-
-    # @private
-    class Attribute
-
-      def initialize name, options = {}
-        @name = name
-        @options = options
-        @request_types = []
-      end
-
-      attr_reader :name
-
-      attr_reader :request_types
-
-      def get_as
-        @get_as ||= (@options[:get_as] || @options[:as] || name)
-      end
-
-      def set_as
-        @set_as ||= (@options[:set_as] || @options[:as] || name)
-      end
-
-      def mutable?
-        @options[:mutable] == true
-      end
-
-      def static?
-        @options[:static] == true
-      end
-
-      def translates_input &block
-        @input_translator = block
-      end
-
-      def translates_output options = {}, &block
-        @translates_nil = options[:nil]
-        @output_translator = block
-      end
-
-      def translate_input_value value
-        @input_translator ? @input_translator.call(value) : value
-      end
-
-      def translate_output_value value
-
-        # by default nil values are not translated
-        return nil if value.nil? and @translates_nil != true
-
-        case
-        when @options[:to_sym]  then value.tr('-','_').downcase.to_sym
-        when @output_translator then @output_translator.call(value)
-        else value
-        end
-
-      end
-
-    end
-
-    # @private
-    class AttributeProvider
-
-      def initialize klass, request_types
-        @klass = klass
-        @id = klass.attribute_providers.length
-        @request_types = request_types
-        @provides = {}
-      end
-
-      attr_reader :request_types
-
-      def find &block
-        @klass.send(:define_method, finder_method, &block)
-      end
-
-      def finder_method
-        "find_in_response_#{@id}"
-      end
-
-      # Indicates that all of the the named attributes can be retrieved
-      # from an appropriate response object.
-      # 
-      # @param [Symbol] attr_names A list of attributes provided
-      # @param [Hash] options
-      # @option options [Boolean] :value_wrapped (false) If true, then
-      #   the value returned by the response object will also receive
-      #   the message :value before it is translated and returned.
-      # @option options [Symbol] :get_as Defaults to the method named
-      #   by the attribute.  This is useful when you have two providers
-      #   for the same attribute but their response object name
-      #   them differently.
-      def provides *attr_names
-        options = attr_names.last.is_a?(Hash) ? attr_names.pop : {}
-        attr_names.each do |attr_name|
-          attr = @klass.attributes[attr_name]
-          attr.request_types.push(*request_types)
-          @provides[attr_name] = options
-        end
-      end
-
-      def attributes_from_response resource, response
-        if response_object = resource.send(finder_method, response)
-          attributes_from_response_object(response_object)
-        else
-          {}
-        end
-      end
-
-      def attributes_from_response_object resp_obj
-        attributes = {}
-        @provides.each do |attr_name, options|
-
-          attr = @klass.attributes[attr_name]
-          method = options[:get_as] || attr.get_as
-
-          v = resp_obj.respond_to?(method) ? resp_obj.send(method) : nil
-          v = v.value if v and options[:value_wrapped]
-          v = attr.translate_output_value(v)
-
-          attributes[attr_name] = v
-
-        end
-        attributes
-      end
-
-    end
-  end
-end

data/lib/aws/response.rb

@@ -1,125 +0,0 @@
-# Copyright 2011 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 'aws/async_handle'
-
-module AWS
-
-  # @private
-  class Response
-
-    include AsyncHandle
-
-    # @return [AWS::Error] Returns nil unless the request failed.
-    #   Normally this will be nil unless you are using the Asynchronous 
-    #   interface.
-    attr_accessor :error
-    
-    # @return [Hash] The hash of options passed to the low level request 
-    #   method that generated this response.
-    attr_accessor :request_options
-
-    # @return [Symbol] The low-level request method that generated
-    #   this response
-    attr_accessor :request_type
-    
-    # @return [Http::Request] the HTTP request object 
-    attr_accessor :http_request
-
-    # @return [Http::Response] the HTTP response object 
-    attr_accessor :http_response
-
-    # @return [Boolean] true if the response is cached
-    attr_accessor :cached
-
-    # @param [Http::Request] http_request
-    # @param [Http::Response] http_request
-    def initialize http_request = nil, http_response = nil, &block
-      @http_request = http_request
-      @http_response = http_response
-      @request_builder = block
-      rebuild_request if @request_builder && !http_request
-    end
-
-    # Rebuilds the HTTP request using the block passed to the initializer
-    def rebuild_request
-      @http_request = @request_builder.call
-    end
-
-    # @return [Boolean] Returns true unless there is a response error.
-    def successful?
-      error.nil?
-    end
-
-    # @return [Boolean] Returns true if the http request was throttled
-    #   by AWS.
-    def throttled?
-      !successful? and
-        http_response.body and
-        parsed_body = XmlGrammar.parse(http_response.body) and
-        parsed_body.respond_to?(:code) and
-        parsed_body.code == "Throttling"
-    end
-
-    # @return [Boolean] Returns true if the http request timed out.
-    def timeout?
-      http_response.timeout?
-    end
-
-    # @private
-    def inspect
-      if request_type
-        "<#{self.class}:#{request_type}>"
-      else
-        "<#{self.class}>"
-      end
-    end
-
-    def cache_key
-      [http_request.access_key_id,
-       http_request.host,
-       request_type,
-       serialized_options].join(":")
-    end
-
-    def serialized_options
-      serialize_options_hash(request_options)
-    end
-
-    private
-    def serialize_options_hash(hash)
-      "(" + hash.keys.sort_by(&:to_s).map do |key|
-        "#{key}=#{serialize_options_value(hash[key])}"
-      end.join(" ") + ")"
-    end
-
-    private
-    def serialize_options_value(value)
-      case value
-      when Hash
-        serialize_options_hash(value)
-      when Array
-        serialize_options_array(value)
-      else
-        value.inspect
-      end
-    end
-
-    private
-    def serialize_options_array(ary)
-      "[" + ary.map { |v| serialize_options_value(v) }.join(" ") +
-        "]"
-    end
-
-  end
-end