aliyun-ess 0.1.0

data/lib/aliyun/ess/error.rb

@@ -0,0 +1,84 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    # Anything you do that makes a request to OSS could result in an error. If it does, the Aliyun::OSS library will raise an exception 
+    # specific to the error. All exception that are raised as a result of a request returning an error response inherit from the 
+    # ResponseError exception. So should you choose to rescue any such exception, you can simple rescue ResponseError. 
+    # 
+    # Say you go to delete a bucket, but the bucket turns out to not be empty. This results in a BucketNotEmpty error (one of the many 
+    # errors listed at http://docs.aliyunwebservices.com/AliyunOSS/2006-03-01/ErrorCodeList.html):
+    # 
+    #   begin
+    #     Bucket.delete('jukebox')
+    #   rescue ResponseError => error
+    #     # ...
+    #   end
+    # 
+    # Once you've captured the exception, you can extract the error message from OSS, as well as the full error response, which includes 
+    # things like the HTTP response code:
+    # 
+    #   error
+    #   # => #<Aliyun::OSS::BucketNotEmpty The bucket you tried to delete is not empty>
+    #   error.message
+    #   # => "The bucket you tried to delete is not empty"
+    #   error.response.code
+    #   # => 409
+    # 
+    # You could use this information to redisplay the error in a way you see fit, or just to log the error and continue on.
+    class Error
+      #:stopdoc:
+      attr_accessor :response
+      attr_reader :error, :exception, :container
+
+      def initialize(error, response = nil)
+        @error     = error
+        @response  = response
+        @container = Aliyun::ESS
+        find_or_create_exception!
+      end
+      
+      def raise
+        Kernel.raise exception.new(message, response)
+      end
+
+      def code
+        @code ||= error['code'].sub('.', '::')
+      end
+      
+      private
+
+      def find_or_create_module!(modul)
+        container.const_defined?(modul) ? container.const_get(modul) : container.const_set(modul, Module.new)
+      end
+
+      def find_or_create_exception!
+        @exception = container.const_defined?(code) ? find_exception : create_exception
+      end
+      
+      def find_exception
+        exception_class = container.const_get(code)
+        Kernel.raise ExceptionClassClash.new(exception_class) unless exception_class.ancestors.include?(ResponseError)
+        exception_class
+      end
+      
+      def create_exception
+        modul_or_clazz, clazz = code.split('::')
+        if clazz
+          find_or_create_module!(modul_or_clazz).const_set(clazz, Class.new(ResponseError))
+        else
+          container.const_set(modul_or_clazz, Class.new(ResponseError))
+        end
+      end
+      
+      def method_missing(method, *args, &block)
+        # We actually want nil if the attribute is nil. So we use has_key? rather than [] + ||.
+        if error.has_key?(method.to_s)
+          error[method.to_s]
+        else
+          super
+        end
+      end
+    end
+  end
+end
+#:startdoc:

data/lib/aliyun/ess/exceptions.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    
+    # Abstract super class of all Aliyun::OSS exceptions
+    class Exception < StandardError
+    end
+    
+    # All responses with a code between 300 and 599 that contain an <Error></Error> body are wrapped in an
+    # ErrorResponse which contains an Error object. This Error class generates a custom exception with the name
+    # of the xml Error and its message. All such runtime generated exception classes descend from ResponseError
+    # and contain the ErrorResponse object so that all code that makes a request can rescue ResponseError and get
+    # access to the ErrorResponse.
+    class ResponseError < Exception
+      attr_reader :response
+      def initialize(message, response)
+        @response = response
+        super(message)
+      end
+    end
+    
+    #:stopdoc:
+    
+    # Most ResponseError's are created just time on a need to have basis, but we explicitly define the
+    # InternalError exception because we want to explicitly rescue InternalError in some cases.
+    class InternalError < ResponseError
+    end
+    
+    class NoSuchKey < ResponseError
+    end
+    
+    class RequestTimeout < ResponseError
+    end
+
+    class InvalidParameter < ResponseError
+    end
+    
+    # Abstract super class for all invalid options.
+    class InvalidOption < Exception
+    end
+
+    module IncorrectCapacity
+    end
+    
+    # Raised if an invalid value is passed to the <tt>:access</tt> option when creating a Bucket or an OSSObject.
+    class InvalidAccessControlLevel < InvalidOption
+      def initialize(valid_levels, access_level)
+        super("Valid access control levels are #{valid_levels.inspect}. You specified `#{access_level}'.")
+      end
+    end
+    
+    # Raised if either the access key id or secret access key arguments are missing when establishing a connection.
+    class MissingAccessKey < InvalidOption
+      def initialize(missing_keys)
+        key_list = missing_keys.map {|key| key.to_s}.join(' and the ')
+        super("You did not provide both required access keys. Please provide the #{key_list}.")
+      end
+    end
+    
+    # Raised if a request is attempted before any connections have been established.
+    class NoConnectionEstablished < Exception
+    end
+    
+    # Raised if an unrecognized option is passed when establishing a connection.
+    class InvalidConnectionOption < InvalidOption
+      def initialize(invalid_options)
+        message = "The following connection options are invalid: #{invalid_options.join(', ')}. "    +
+                  "The valid connection options are: #{Connection::Options::VALID_OPTIONS.join(', ')}."
+        super(message)
+      end
+    end
+    
+    class ExceptionClassClash < Exception #:nodoc:
+      def initialize(klass)
+        message = "The exception class you tried to create (`#{klass}') exists and is not an exception"
+        super(message)
+      end
+    end
+    
+    #:startdoc:
+  end
+end

data/lib/aliyun/ess/extensions.rb

@@ -0,0 +1,174 @@
+# -*- encoding : utf-8 -*-
+#:stopdoc:
+
+class Hash
+  def slice(*keys)
+    keys.map! { |key| key.to_s }
+    keys.inject(Hash.new) { |hash, k| hash[k] = self[k] if has_key?(k); hash }
+  end unless public_method_defined? :slice
+end
+
+class String
+  # ActiveSupport adds an underscore method to String so let's just use that one if
+  # we find that the method is already defined
+  def underscore
+    gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").downcase
+  end unless public_method_defined? :underscore
+
+  def camelize
+    string = to_s.sub(/^[a-z\d]*/) { $&.capitalize }
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    string.gsub!(/\//, '::')
+    string
+  end unless public_method_defined? :camelize
+
+  if RUBY_VERSION >= '1.9'
+    def valid_utf8?
+      dup.force_encoding('UTF-8').valid_encoding?
+    end
+  else
+    def valid_utf8?
+      scan(Regexp.new('[^\x00-\xa0]', nil, 'u')) { |s| s.unpack('U') }
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+  
+  # All paths in in OSS have to be valid unicode so this takes care of 
+  # cleaning up any strings that aren't valid utf-8 according to String#valid_utf8?
+  if RUBY_VERSION >= '1.9'
+    def remove_extended!
+      sanitized_string = ''
+      each_byte do |byte|
+        character = byte.chr
+        sanitized_string << character if character.ascii_only?
+      end
+      sanitized_string
+    end
+  else
+    def remove_extended!
+      #gsub!(/[\x80-\xFF]/) { "%02X" % $&[0] }
+      gsub!(Regext.new('/[\x80-\xFF]')) { "%02X" % $&[0] }
+    end
+  end
+  
+  def remove_extended
+    dup.remove_extended!
+  end
+end
+
+class CoercibleString < String
+  class << self
+    def coerce(string)
+      new(string).coerce
+    end
+  end
+  
+  def coerce
+    case self
+    when 'true';         true
+    when 'false';         false
+    # Don't coerce numbers that start with zero
+    when  /^[1-9]+\d*$/;   Integer(self)
+    when datetime_format; Time.parse(self)
+    else
+      self
+    end
+  end
+  
+  private
+    # Lame hack since Date._parse is so accepting. OSS dates are of the form: '2006-10-29T23:14:47.000Z'
+    # so unless the string looks like that, don't even try, otherwise it might convert an object's
+    # key from something like '03 1-2-3-Apple-Tree.mp3' to Sat Feb 03 00:00:00 CST 2001.
+    def datetime_format
+      /^\d{4}-\d{2}-\d{2}\w\d{2}:\d{2}:\d{2}/
+    end
+end
+
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end if Class.instance_methods(false).grep(/^cattr_(?:reader|writer|accessor)$/).empty?
+
+module SelectiveAttributeProxy
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.class_eval(<<-EVAL, __FILE__, __LINE__)
+      cattr_accessor :attribute_proxy
+      cattr_accessor :attribute_proxy_options
+      
+      # Default name for attribute storage
+      self.attribute_proxy         = :attributes
+      self.attribute_proxy_options = {:exclusively => true}
+      
+      private
+        # By default proxy all attributes
+        def proxiable_attribute?(name)
+          return true unless self.class.attribute_proxy_options[:exclusively]
+          send(self.class.attribute_proxy).has_key?(name)
+        end
+        
+        def method_missing(method, *args, &block)
+          # Autovivify attribute storage
+          if method == self.class.attribute_proxy
+            ivar = "@\#{method}"
+            instance_variable_set(ivar, {}) unless instance_variable_get(ivar).is_a?(Hash)
+            instance_variable_get(ivar)
+          # Delegate to attribute storage
+          elsif method.to_s =~ /^(\\w+)(=?)$/ && proxiable_attribute?($1)
+            attributes_hash_name = self.class.attribute_proxy
+            $2.empty? ? send(attributes_hash_name)[$1] : send(attributes_hash_name)[$1] = args.first
+          else
+            super
+          end
+        end
+    EVAL
+  end
+
+  module ClassMethods
+  end
+end
+
+#:startdoc:

data/lib/aliyun/ess/parsing.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+#:stopdoc:
+module Aliyun
+  module ESS
+    module Parsing
+      
+      module Typecasting
+        def typecast(object)
+          case object
+          when Hash
+            typecast_hash(object)
+          when Array
+            object.map {|element| typecast(element)}
+          when String
+            CoercibleString.coerce(object)
+          else
+            object
+          end
+        end
+        
+        def typecast_hash(hash)
+          keys   = hash.keys.map {|key| key.underscore}
+          values = hash.values.map {|value| typecast(value)}
+          keys.inject({}) do |new_hash, key|
+            new_hash[key] = values.slice!(0)
+            new_hash
+          end
+        end
+      end
+
+      class JsonParser < Hash
+        include Typecasting
+        
+        attr_reader :body, :code
+
+        def initialize(body)
+          @body = body
+          unless body.strip.empty?
+            parse
+            typecast_json_parsed
+            set_code
+          end
+        end
+
+        private
+
+        def parse
+          @json_parsed = JSON.parse(body)
+        end
+
+        def set_code
+          @code = self['code']
+        end
+
+        def typecast_json_parsed
+          typecast_json = {}
+          @json_parsed.dup.each do |key, value| # Some typecasting is destructive so we dup
+            typecast_json[key.underscore] = typecast(value)
+          end
+          # An empty body will try to update with a string so only update if the result is a hash
+          update(typecast_json) unless typecast_json.keys.size==0
+        end
+      end
+    end
+  end
+end
+#:startdoc:

data/lib/aliyun/ess/response.rb

@@ -0,0 +1,161 @@
+# -*- encoding : utf-8 -*-
+#:stopdoc:
+module Aliyun
+  module ESS
+    class Base
+      class Response < String  
+        attr_reader :response, :body, :parsed
+        def initialize(response)
+          @response = response
+          @body     = response.body.to_s
+          super(body)
+        end
+    
+        def headers
+          @headers ||= begin
+            headers = {}
+            response.each do |header, value|
+              headers[header] = value
+            end
+            headers
+          end
+        end
+    
+        def [](header)
+          headers[header]
+        end
+    
+        def each(&block)
+          headers.each(&block)
+        end
+    
+        def code
+          response.code.to_i
+        end
+    
+        {:success      => 200..299, :redirect     => 300..399,
+         :client_error => 400..499, :server_error => 500..599}.each do |result, code_range|
+          class_eval(<<-EVAL, __FILE__, __LINE__)
+            def #{result}? 
+              return false unless response
+              (#{code_range}).include? code
+            end
+          EVAL
+        end
+    
+        def error?
+          !success? && !parsed.code.nil?
+        end
+    
+        def error
+          @error ||= Error.new(parsed, self)
+        end
+    
+        def parsed
+          # XmlSimple is picky about what kind of object it parses, so we pass in body rather than self
+          @parsed ||= Parsing::JsonParser.new(body)
+        end
+    
+        def inspect
+          "#<%s:0x%s %s %s>" % [self.class, object_id, response.code, response.message]
+        end
+      end
+    end
+
+    class ScalingGroup
+      class Response < Base::Response
+        def items
+          (parsed['scaling_groups'] && parsed['scaling_groups']['scaling_group']) || []
+        end
+      end
+    end
+
+    class ScalingRule
+      class Response < Base::Response
+        def items
+          (parsed['scaling_rules'] && parsed['scaling_rules']['scaling_rule']) || []
+        end
+      end
+    end
+    
+
+    # Requests whose response code is between 300 and 599 and contain an <Error></Error> in their body
+    # are wrapped in an Error::Response. This Error::Response contains an Error object which raises an exception
+    # that corresponds to the error in the response body. The exception object contains the ErrorResponse, so
+    # in all cases where a request happens, you can rescue ResponseError and have access to the ErrorResponse and
+    # its Error object which contains information about the ResponseError.
+    #
+    #   begin
+    #     Bucket.create(..)
+    #   rescue ResponseError => exception
+    #    exception.response
+    #    # => <Error::Response>
+    #    exception.response.error
+    #    # => <Error>
+    #   end
+    class Error
+      class Response < Base::Response
+        def error? 
+          true
+        end
+      
+        def inspect
+          "#<%s:0x%s %s %s: '%s'>" % [self.class.name, object_id, response.code, error.code, error.message]
+        end
+      end
+    end
+
+    # Guess response class name from current class name. If the guessed response class doesn't exist
+    # do the same thing to the current class's parent class, up the inheritance heirarchy until either
+    # a response class is found or until we get to the top of the heirarchy in which case we just use 
+    # the the Base response class.
+    #
+    # Important: This implemantation assumes that the Base class has a corresponding Base::Response.
+    class FindResponseClass #:nodoc:
+      class << self
+        def for(start)
+          new(start).find
+        end
+      end
+  
+      def initialize(start)
+        @container     = Aliyun::ESS
+        @current_class = start
+      end
+  
+      def find
+        self.current_class = current_class.superclass until response_class_found?            
+        target.const_get(class_to_find)
+      end
+  
+      private
+        attr_reader :container
+        attr_accessor :current_class
+        
+        def target
+          container.const_get(current_name)
+        end
+        
+        def target?
+          container.const_defined?(current_name)
+        end
+        
+        def response_class_found?
+          target? && target.const_defined?(class_to_find)
+        end
+        
+        def class_to_find
+          :Response
+        end
+        
+        def current_name
+          truncate(current_class)
+        end
+        
+        def truncate(klass)
+          klass.name[/[^:]+$/]
+        end
+      end
+  end
+end
+#:startdoc: