aliyun-ess 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6220299fa48afc6abb759b80526dac2889b0052c
+  data.tar.gz: 6c6b2757addd2ae6314f5951823c3c16b2f7a2aa
+SHA512:
+  metadata.gz: ca60cb188e0e809e4169a58d25486f591ef59e8800fb52e0a306961017e7613734d9aa67413a1b95814be5e2c725331d503a75e602cdc19644c34b1810a09785
+  data.tar.gz: af36c635c32689e74a812381008171e674e5d837e653743d2a61f7726355509ea6f07d03f55dd8ec5cbc3510d1de455885861a0895318d50e759d729b6813c9b

data/CHANGELOG

@@ -0,0 +1,5 @@
+head:
+
+0.1.0:
+
+- Initial public release

data/INSTALL

@@ -0,0 +1,13 @@
+== Rubygems
+
+The easiest way to install aliyun/oss is with Rubygems:
+
+  % gem i aliyun-ess -ry
+ 
+== Directly from git
+
+ % git clone git://github.com/sunrisela/aliyun-ess-sdk-for-ruby.git
+  
+== Dependencies
+
+Aliyun::ESS requires Ruby 1.9+. 

data/bin/ess

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+lib      = File.dirname(__FILE__) + '/../lib/aliyun/ess'
+setup    = File.dirname(__FILE__) + '/setup'
+irb_name = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
+
+exec "#{irb_name} -r #{lib} -r #{setup} "

data/bin/setup.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+#!/usr/bin/env ruby
+if ENV['ACCESS_KEY_ID'] && ENV['SECRET_ACCESS_KEY']
+  Aliyun::ESS::Base.establish_connection!(
+    :access_key_id     => ENV['ACCESS_KEY_ID'], 
+    :secret_access_key => ENV['SECRET_ACCESS_KEY']
+  )
+end
+
+#require File.dirname(__FILE__) + '/../test/fixtures'
+include Aliyun::ESS

data/lib/aliyun/ess.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+require 'cgi'
+require 'uri'
+require 'openssl'
+require 'digest/sha1'
+require 'net/https'
+require 'time'
+require 'date'
+require 'open-uri'
+require 'yajl/json_gem'
+require 'rack/utils'
+require 'byebug'
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'ess/version'
+require 'ess/extensions' unless defined? Aliyun::OSS
+require 'ess/exceptions'
+require 'ess/error'
+require 'ess/authentication'
+require 'ess/connection'
+require 'ess/parsing'
+require 'ess/base'
+require 'ess/service'
+require 'ess/collection'
+require 'ess/scaling_group'
+require 'ess/scaling_rule'
+require 'ess/response'
+
+
+Aliyun::ESS::Base.class_eval do
+  include Aliyun::ESS::Connection::Management
+end

data/lib/aliyun/ess/authentication.rb

@@ -0,0 +1,121 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    class Authentication
+      class Signature < String #:nodoc:
+        attr_reader :params, :access_key_id, :secret_access_key, :options
+  
+        def initialize(params, access_key_id, secret_access_key, options = {})
+          super()
+          @params, @access_key_id, @secret_access_key = params, access_key_id, secret_access_key
+          @options = options
+        end
+  
+        private
+
+        def escape_string(str)
+          CGI.escape(str).gsub(/\+/,'%20').gsub(/%7E/, '~')
+        end
+    
+        def sign_string
+          StringToSign.new(canonical_string)
+        end
+
+        def canonical_string
+          @canonical_string ||= CanonicalString.new(params, access_key_id, {})
+        end
+  
+        def encoded_canonical
+          digest   = OpenSSL::Digest::Digest.new('sha1')
+          b64_hmac = [OpenSSL::HMAC.digest(digest, secret_access_key+'&', sign_string)].pack("m").strip
+          url_encode? ? CGI.escape(b64_hmac) : b64_hmac
+        end
+        
+        def url_encode?
+          !@options[:url_encode].nil?
+        end
+      end
+
+      class QueryString < Signature
+        def initialize(*args)
+          super
+          self << build
+        end
+
+        private
+
+        def build
+          "#{canonical_string}&Signature=#{escape_string(encoded_canonical)}"
+        end
+      end
+
+      class StringToSign < String
+        attr_reader :canonicalized_query_string
+        def initialize(canonicalized_query_string)
+          super()
+          @canonicalized_query_string = canonicalized_query_string
+          build
+        end
+
+        private
+
+        def build
+          self << 'GET'
+          self << '&%2F&'
+          self << escape_string(canonicalized_query_string)
+        end
+
+        def escape_string(str)
+          CGI.escape(str).gsub(/\+/,'%20').gsub(/%7E/, '~')
+        end
+      end
+
+      class CanonicalString < String
+        DEFAULT_PARAMS = {
+          'Format'           => 'JSON',
+          'SignatureMethod'  => 'HMAC-SHA1',
+          'SignatureVersion' => '1.0',
+          'Version'          => '2014-08-28'
+        }
+
+        attr_reader :params, :query
+
+        def initialize(params, access_key_id, options = {})
+          super()
+          @params        = params
+          @access_key_id = access_key_id
+          @options       = options
+          self << build
+        end
+
+        private
+
+        def build
+          initialize_query
+
+          canonicalized_query_string = query.sort_by{|k, _| k}.map do |key, value|
+            value = value.to_s.strip
+            escaped_value = escape_string(value)
+            "#{key}=#{escaped_value}"
+          end.join('&')
+
+          canonicalized_query_string
+        end
+
+        def escape_string(str)
+          CGI.escape(str).gsub(/\+/,'%20').gsub(/%7E/, '~')
+        end
+
+        def initialize_query
+          @query = { 'AccessKeyId' => @access_key_id }
+          @query = params.merge(@query)
+          @query = DEFAULT_PARAMS.merge('SignatureNonce' => random_string, 'Timestamp' => Time.now.utc.iso8601).merge(@query)
+        end
+
+        def random_string(len=32)
+          rand(36**(len-1)..36**(len)).to_s 36
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/ess/base.rb

@@ -0,0 +1,128 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    DEFAULT_HOST = 'ess.aliyuncs.com'
+    class Base
+      class << self
+        # Wraps the current connection's request method and picks the appropriate response class to wrap the response in.
+        # If the response is an error, it will raise that error as an exception. All such exceptions can be caught by rescuing
+        # their superclass, the ResponseError exception class.
+        #
+        # It is unlikely that you would call this method directly. Subclasses of Base have convenience methods for each http request verb
+        # that wrap calls to request.
+        def request(verb, path, params = {}, options = {}, body = nil, attempts = 0, &block)
+          Service.response = nil
+          process_params!(params, verb)
+          response = response_class.new(connection.request(verb, path, params, options, body, attempts, &block))
+          Service.response = response
+
+          Error::Response.new(response.response).error.raise if response.error?
+          response
+        # Once in a while, a request to OSS returns an internal error. A glitch in the matrix I presume. Since these 
+        # errors are few and far between the request method will rescue InternalErrors the first three times they encouter them
+        # and will retry the request again. Most of the time the second attempt will work.
+        rescue InternalError, RequestTimeout
+          if attempts == 3
+            raise
+          else
+            attempts += 1
+            retry
+          end
+        end
+
+        [:get, :post, :put, :delete, :head].each do |verb|
+          class_eval(<<-EVAL, __FILE__, __LINE__)
+            def #{verb}(path, params = {}, headers = {}, body = nil, &block)
+              request(:#{verb}, path, params, headers, body, &block)
+            end
+          EVAL
+        end
+
+        private
+
+        def response_class
+          FindResponseClass.for(self)
+        end
+
+        def process_params!(params, verb)
+          params.replace(RequestParams.process(params, verb))
+        end
+        
+        # Using the conventions layed out in the <tt>response_class</tt> works for more than 80% of the time.
+        # There are a few edge cases though where we want a given class to wrap its responses in different
+        # response classes depending on which method is being called.
+        def respond_with(klass)
+          eval(<<-EVAL, binding, __FILE__, __LINE__)
+            def new_response_class
+              #{klass}
+            end
+            class << self
+              alias_method :old_response_class, :response_class
+              alias_method :response_class, :new_response_class
+            end
+          EVAL
+          yield
+        ensure
+          # Restore the original version
+          eval(<<-EVAL, binding, __FILE__, __LINE__)
+            class << self
+              alias_method :response_class, :old_response_class
+            end
+          EVAL
+        end
+
+        class RequestParams < Hash #:nodoc:
+          attr_reader :options, :verb
+          
+          class << self
+            def process(*args, &block)
+              new(*args, &block).process!
+            end
+          end
+          
+          def initialize(options, verb = :get)
+            @options = options.inject({}) {|h, (k,v)| h[k.to_s.camelize] = v.to_s; h }
+            @verb    = verb
+            super()
+          end
+          
+          def process!
+            replace(options)
+          end
+        end
+      end
+
+      def initialize(attributes = {}) #:nodoc:
+        @attributes = attributes
+      end
+      
+      private
+
+      attr_reader :attributes
+      
+      def connection
+        self.class.connection
+      end
+      
+      def http
+        connection.http
+      end
+      
+      def request(*args, &block)
+        self.class.request(*args, &block)
+      end
+      
+      def method_missing(method, *args, &block)
+        case
+        when attributes.has_key?(method.to_s) 
+          attributes[method.to_s]
+        when attributes.has_key?(method)
+          attributes[method]
+        else 
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/aliyun/ess/collection.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    class Collection
+      include SelectiveAttributeProxy
+
+      attr_reader :response, :attributes
+
+      def initialize(response)
+        @response   = response
+        @attributes = response.parsed.slice(*%W{page_number page_size total_count})
+      end
+
+      def items
+        @items ||= build_items!
+      end
+
+      def build_items!
+        item_class = eval response.class.name.sub(/::Response$/, '')
+        response.items.map{|e| item_class.new e }
+      end
+    end
+  end
+end

data/lib/aliyun/ess/connection.rb

@@ -0,0 +1,226 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module ESS
+    class Connection #:nodoc:
+      class << self
+        def connect(options = {})
+          new(options)
+        end
+        
+        def prepare_path(path)
+          path = path.remove_extended unless path.valid_utf8?
+          URI.escape(path)
+        end
+      end
+      
+      attr_reader :access_key_id, :secret_access_key, :http, :options
+      
+      # Creates a new connection. Connections make the actual requests to OSS, though these requests are usually 
+      # called from subclasses of Base.
+      # 
+      # For details on establishing connections, check the Connection::Management::ClassMethods.
+      def initialize(options = {})
+        @options = Options.new(options)
+        connect
+      end
+          
+      def request(verb, path, params = {}, headers = {}, body = nil, attempts = 0, &block)
+        body.rewind if body.respond_to?(:rewind) unless attempts.zero?      
+        
+        requester = Proc.new do 
+          path    = self.class.prepare_path(path) if attempts.zero? # Only escape the path once
+          params  = ::Rack::Utils.parse_nested_query(URI(path).query).merge(params)
+          
+          request_uri = "/?"+query_string_authentication(params)
+
+          puts request_uri
+
+          request = request_method(verb).new(request_uri, headers)
+          add_user_agent!(request)
+          
+          if body
+            if body.respond_to?(:read)                                                                
+              request.body_stream = body                                                           
+            else                                                                                      
+              request.body = body                                                                     
+            end
+            request.content_length = body.respond_to?(:lstat) ? body.stat.size : body.size         
+          else
+            request.content_length = 0                                                                                       
+          end
+          http.request(request, &block)
+        end
+        
+        if persistent?
+          http.start unless http.started?
+          requester.call
+        else
+          http.start(&requester)
+        end
+      rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError
+        @http = create_connection
+        attempts == 3 ? raise : (attempts += 1; retry)
+      end
+      
+      def persistent?
+        options[:persistent]
+      end
+      
+      def protocol(options = {})
+        # This always trumps http.use_ssl?
+        if options[:use_ssl] == false 
+          'http://'
+        elsif options[:use_ssl] || http.use_ssl?
+          'https://'
+        else
+          'http://'
+        end
+      end
+      
+      private
+        def extract_keys!
+          missing_keys = []
+          extract_key = Proc.new {|key| options[key] || (missing_keys.push(key); nil)}
+          @access_key_id     = extract_key[:access_key_id]
+          @secret_access_key = extract_key[:secret_access_key]
+          raise MissingAccessKey.new(missing_keys) unless missing_keys.empty?
+        end
+        
+        def create_connection
+          http             = Net::HTTP.new(options[:server], options[:port])
+          http.use_ssl     = !options[:use_ssl].nil? || options[:port] == 443
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http
+        end
+        
+        def connect
+          extract_keys!
+          @http = create_connection
+        end
+
+        def port_string
+          default_port = options[:use_ssl] ? 443 : 80
+          http.port == default_port ? '' : ":#{http.port}"
+        end
+
+        # do authentication for now
+        def query_string_authentication(params)
+          Authentication::QueryString.new(params, access_key_id, secret_access_key)
+        end
+        
+        def add_user_agent!(request)
+          request['User-Agent'] ||= "Aliyun::ESS/#{Version}"
+        end
+        
+        def request_method(verb)
+          Net::HTTP.const_get(verb.to_s.capitalize)
+        end
+        
+        def method_missing(method, *args, &block)
+          options[method] || super
+        end
+        
+      module Management #:nodoc:
+        def self.included(base)
+          base.cattr_accessor :connections
+          base.connections = {}
+          base.extend ClassMethods
+        end
+        
+        # Manage the creation and destruction of connections for Aliyun::OSS::Base and its subclasses. Connections are
+        # created with establish_connection!.
+        module ClassMethods
+          # Creates a new connection with which to make requests to the ESS servers for the calling class.
+          #   
+          #   Aliyun::ESS::Base.establish_connection!(:access_key_id => '...', :secret_access_key => '...')
+          #
+          # == Required arguments
+          #
+          # * <tt>:access_key_id</tt> - The access key id for your OSS account. Provided by Aliyun.
+          # * <tt>:secret_access_key</tt> - The secret access key for your OSS account. Provided by Aliyun.
+          #
+          # If any of these required arguments is missing, a MissingAccessKey exception will be raised.
+          #
+          # == Optional arguments
+          #
+          # * <tt>:server</tt> - The server to make requests to. You can use this to specify your bucket in the subdomain,
+          # or your own domain's cname if you are using virtual hosted buckets. Defaults to <tt>oss.aliyuncs.com</tt>.
+          # * <tt>:port</tt> - The port to the requests should be made on. Defaults to 80 or 443 if the <tt>:use_ssl</tt>
+          # argument is set.
+          # * <tt>:use_ssl</tt> - Whether requests should be made over SSL. If set to true, the <tt>:port</tt> argument
+          # will be implicitly set to 443, unless specified otherwise. Defaults to false.
+          # * <tt>:persistent</tt> - Whether to use a persistent connection to the server. Having this on provides around a two fold 
+          # performance increase but for long running processes some firewalls may find the long lived connection suspicious and close the connection.
+          # If you run into connection errors, try setting <tt>:persistent</tt> to false. Defaults to false.
+          def establish_connection!(options = {})
+            # After you've already established the default connection, just specify 
+            # the difference for subsequent connections
+            options = default_connection.options.merge(options) if connected?
+            connections[connection_name] = Connection.connect(options)
+          end
+          
+          # Returns the connection for the current class, or Base's default connection if the current class does not
+          # have its own connection.
+          #
+          # If not connection has been established yet, NoConnectionEstablished will be raised.
+          def connection
+            if connected?
+              connections[connection_name] || default_connection
+            else
+              raise NoConnectionEstablished
+            end
+          end
+          
+          # Returns true if a connection has been made yet.
+          def connected?
+            !connections.empty?
+          end
+          
+          # Removes the connection for the current class. If there is no connection for the current class, the default
+          # connection will be removed.
+          def disconnect(name = connection_name)
+            name       = default_connection unless connections.has_key?(name)
+            connection = connections[name]
+            connection.http.finish if connection.persistent?
+            connections.delete(name)
+          end
+          
+          # Clears *all* connections, from all classes, with prejudice. 
+          def disconnect!
+            connections.each_key {|connection| disconnect(connection)}
+          end
+
+          private
+            def connection_name
+              name
+            end
+
+            def default_connection_name
+              'Aliyun::ESS::Base'
+            end
+
+            def default_connection
+              connections[default_connection_name]
+            end
+        end
+      end
+        
+      class Options < Hash #:nodoc:
+        VALID_OPTIONS = [:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent].freeze
+        
+        def initialize(options = {})
+          super()
+          validate(options)
+          replace(:server => DEFAULT_HOST, :port => (options[:use_ssl] ? 443 : 80))
+          merge!(options)
+        end
+        
+        private
+          def validate(options)
+            invalid_options = options.keys - VALID_OPTIONS
+            raise InvalidConnectionOption.new(invalid_options) unless invalid_options.empty?
+          end
+      end
+    end
+  end
+end