Improve User-Agent

Author: JacksonTian

Makefile

@@ -1,7 +1,8 @@
 .PHONY: test install build deploy
 
 test:
-rspec --format doc
+bundle exec rspec --format doc --exclude-pattern spec/**/*_integration_spec.rb
+bundle exec rspec --format doc -P spec/**/*_integration_spec.rb
 
 deploy:
 $(eval VERSION := $(shell cat lib/aliyunsdkcore.rb | grep 'VERSION = ' | cut -d\" -f2))

aliyunsdkcore.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
  s.add_dependency 'faraday', '~> 0.15.4'
  s.add_dependency 'activesupport', '>= 4.0.0'
 
- s.add_development_dependency "simplecov"
- s.add_development_dependency "rspec"
+ s.add_development_dependency "simplecov", ">= 0.16.1"
+ s.add_development_dependency "rspec", ">= 3.8.0"
  s.add_development_dependency "codecov", ">= 0.1.10"
 end

lib/aliyunsdkcore.rb

@@ -1,6 +1,11 @@
-require_relative './rpc_client'
-require_relative './roa_client'
+require 'aliyunsdkcore/rpc_client'
+require 'aliyunsdkcore/roa_client'
 
 module AliyunSDKCore
  VERSION = "0.0.7"
+ DEFAULT_UA = "AlibabaCloud (#{Gem::Platform.local.os}; " +
+ "#{Gem::Platform.local.cpu}) Ruby/#{RUBY_VERSION} Core/#{VERSION}"
 end
+
+RPCClient = AliyunSDKCore::RPCClient
+ROAClient = AliyunSDKCore::ROAClient

lib/aliyunsdkcore/roa_client.rb

@@ -0,0 +1,159 @@
+require 'faraday'
+require 'securerandom'
+require 'active_support/all'
+
+def present?(obj)
+ obj.respond_to?(:empty?) ? !obj.empty? : obj
+end
+
+module AliyunSDKCore
+
+ class ROAClient
+
+ attr_accessor :endpoint, :api_version, :access_key_id,
+ :access_key_secret, :security_token, :hostname, :opts
+
+ def initialize(config)
+ validate config
+
+ self.endpoint = config[:endpoint]
+ self.api_version = config[:api_version]
+ self.access_key_id = config[:access_key_id]
+ self.access_key_secret = config[:access_key_secret]
+ self.security_token = config[:security_token]
+ end
+
+ def request(method:, uri:, params: {}, body: {}, headers: {}, options: {})
+
+ mix_headers = default_headers.merge(headers)
+
+ response = connection.send(method.downcase) do |request|
+ request.url uri, params
+ if present?(body)
+ request_body = body.to_json
+ request.body = request_body
+ mix_headers['content-md5'] = Digest::MD5.base64digest request_body
+ mix_headers['content-length'] = request_body.length.to_s
+ end
+ string2sign = string_to_sign(method, uri, mix_headers, params)
+ mix_headers.merge!(authorization: authorization(string2sign))
+ mix_headers.each { |key, value| request.headers[key] = value }
+ end
+
+ return response if options.has_key? :raw_body
+
+ response_content_type = response.headers['Content-Type'] || ''
+ if response_content_type.start_with?('application/json')
+ if response.status >= 400
+ result = JSON.parse(response.body)
+ raise StandardError, "code: #{response.status}, #{result['Message']} requestid: #{result['RequestId']}"
+ end
+ end
+
+ if response_content_type.start_with?('text/xml')
+ result = Hash.from_xml(response.body)
+ raise ACSError, result['Error'] if result['Error']
+ end
+
+ response
+ end
+
+ def connection(adapter = Faraday.default_adapter)
+ Faraday.new(:url => self.endpoint) { |faraday| faraday.adapter adapter }
+ end
+
+ def get(uri: '', headers: {}, params: {}, options: {})
+ request(method: :get, uri: uri, params: params, body: {}, headers: headers, options: options)
+ end
+
+ def post(uri: '', headers: {}, params: {}, body: {}, options: {})
+ request(method: :get, uri: uri, params: params, body: body, headers: headers, options: options)
+ end
+
+ def put(uri: '', headers: {}, params: {}, body: {}, options: {})
+ request(method: :get, uri: uri, params: params, body: body, headers: headers, options: options)
+ end
+
+ def delete(uri: '', headers: {}, params: {}, options: {})
+ request(method: :get, uri: uri, params: params, body: {}, headers: headers, options: options)
+ end
+
+ def default_headers
+ default_headers = {
+ 'accept' => 'application/json',
+ 'date' => Time.now.httpdate,
+ 'host' => URI(self.endpoint).host,
+ 'x-acs-signature-nonce' => SecureRandom.hex(16),
+ 'x-acs-signature-method' => 'HMAC-SHA1',
+ 'x-acs-signature-version' => '1.0',
+ 'x-acs-version' => self.api_version,
+ 'x-sdk-client' => "RUBY(#{RUBY_VERSION})", # FIXME: 如何获取Gem的名称和版本号
+ 'user-agent' => DEFAULT_UA
+ }
+ if self.security_token
+ default_headers.merge!(
+ 'x-acs-accesskey-id' => self.access_key_id,
+ 'x-acs-security-token' => self.security_token
+ )
+ end
+ default_headers
+ end
+
+ private
+
+ def string_to_sign(method, uri, headers, query = {})
+ header_string = [
+ method,
+ headers['accept'],
+ headers['content-md5'] || '',
+ headers['content-type'] || '',
+ headers['date'],
+ ].join("\n")
+ "#{header_string}\n#{canonicalized_headers(headers)}#{canonicalized_resource(uri, query)}"
+ end
+
+ def canonicalized_headers(headers)
+ headers.keys.select { |key| key.to_s.start_with? 'x-acs-' }
+ .sort.map { |key| "#{key}:#{headers[key].strip}\n" }.join
+ end
+
+ def canonicalized_resource(uri, query_hash = {})
+ query_string = query_hash.map { |key, value| "#{key}=#{value}" }.join('&')
+ query_string.empty? ? uri : "#{uri}?#{query_string}"
+ end
+
+ def authorization(string_to_sign)
+ "acs #{self.access_key_id}:#{signature(string_to_sign)}"
+ end
+
+ def signature(string_to_sign)
+ Base64.encode64(OpenSSL::HMAC.digest('sha1', self.access_key_secret, string_to_sign)).strip
+ end
+
+ def validate(config)
+ raise ArgumentError, 'must pass "config"' unless config
+ raise ArgumentError, 'must pass "config[:endpoint]"' unless config[:endpoint]
+ unless config[:endpoint].start_with?('http://') || config[:endpoint].start_with?('https://')
+ raise ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.'
+ end
+ raise ArgumentError, 'must pass "config[:api_version]"' unless config[:api_version]
+ raise ArgumentError, 'must pass "config[:access_key_id]"' unless config[:access_key_id]
+ raise ArgumentError, 'must pass "config[:access_key_secret]"' unless config[:access_key_secret]
+ end
+
+ class ACSError < StandardError
+
+ attr_accessor :code
+
+ def initialize(error)
+ self.code = error['Code']
+ message = error['Message']
+ host_id = error['HostId']
+ request_id = error['RequestId']
+ super("#{message} host_id: #{host_id}, request_id: #{request_id}")
+ end
+
+ end
+
+ end
+end

lib/aliyunsdkcore/rpc_client.rb

@@ -0,0 +1,145 @@
+require 'set'
+require 'openssl'
+require 'faraday'
+require 'active_support/all'
+
+# Converts just the first character to uppercase.
+#
+# upcase_first('what a Lovely Day') # => "What a Lovely Day"
+# upcase_first('w') # => "W"
+# upcase_first('') # => ""
+def upcase_first(string)
+ string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+end
+
+module AliyunSDKCore
+
+ class RPCClient
+
+ attr_accessor :endpoint, :api_version, :access_key_id, :access_key_secret, :security_token, :codes, :opts, :verbose
+
+ def initialize(config, verbose = false)
+
+ validate config
+
+ self.endpoint = config[:endpoint]
+ self.api_version = config[:api_version]
+ self.access_key_id = config[:access_key_id]
+ self.access_key_secret = config[:access_key_secret]
+ self.security_token = config[:security_token]
+ self.opts = config[:opts] || {}
+ self.verbose = verbose.instance_of?(TrueClass) && verbose
+ self.codes = Set.new [200, '200', 'OK', 'Success']
+ self.codes.merge config[:codes] if config[:codes]
+ end
+
+ def request(action:, params: {}, opts: {})
+ opts = self.opts.merge(opts)
+ action = upcase_first(action) if opts[:format_action]
+ params = format_params(params) unless opts[:format_params]
+ defaults = default_params
+ params = { Action: action }.merge(defaults).merge(params)
+ method = (opts[:method] || 'GET').upcase
+ normalized = normalize(params)
+ canonicalized = canonicalize(normalized)
+ string_to_sign = "#{method}&#{encode('/')}&#{encode(canonicalized)}"
+ key = self.access_key_secret + '&'
+ signature = Base64.encode64(OpenSSL::HMAC.digest('sha1', key, string_to_sign)).strip
+ normalized.push(['Signature', encode(signature)])
+
+ querystring = canonicalize(normalized)
+
+ uri = opts[:method] == 'POST' ? '/' : "/?#{querystring}"
+
+ response = connection.send(method.downcase, uri) do |request|
+ request.headers['User-Agent'] = DEFAULT_UA
+ if opts[:method] == 'POST'
+ request.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+ request.body = querystring
+ end
+ end
+
+ response_body = JSON.parse(response.body)
+ if response_body['Code'] && !self.codes.include?(response_body['Code'])
+ raise StandardError, "#{response_body['Message']}, URL: #{uri}"
+ end
+
+ response_body
+ end
+
+ private
+
+ def connection(adapter = Faraday.default_adapter)
+ Faraday.new(:url => self.endpoint) { |faraday| faraday.adapter adapter }
+ end
+
+ def default_params
+ default_params = {
+ 'Format' => 'JSON',
+ 'SignatureMethod' => 'HMAC-SHA1',
+ 'SignatureNonce' => SecureRandom.hex(16),
+ 'SignatureVersion' => '1.0',
+ 'Timestamp' => Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ'),
+ 'AccessKeyId' => self.access_key_id,
+ 'Version' => self.api_version,
+ }
+ default_params.merge!('SecurityToken' => self.security_token) if self.security_token
+ default_params
+ end
+
+ def encode(string)
+ encoded = CGI.escape string
+ encoded.gsub(/[\+]/, '%20')
+ end
+
+ def format_params(param_hash)
+ param_hash.keys.each { |key| param_hash[upcase_first(key.to_s).to_sym] = param_hash.delete key }
+ param_hash
+ end
+
+ def replace_repeat_list(target, key, repeat)
+ repeat.each_with_index do |item, index|
+ if item && item.instance_of?(Hash)
+ item.each_key { |k| target["#{key}.#{index.next}.#{k}"] = item[k] }
+ else
+ target["#{key}.#{index.next}"] = item
+ end
+ end
+ target
+ end
+
+ def flat_params(params)
+ target = {}
+ params.each do |key, value|
+ if value.instance_of?(Array)
+ replace_repeat_list(target, key, value)
+ else
+ target[key.to_s] = value
+ end
+ end
+ target
+ end
+
+ def normalize(params)
+ flat_params(params)
+ .sort
+ .to_h
+ .map { |key, value| [encode(key), encode(value)] }
+ end
+
+ def canonicalize(normalized)
+ normalized.map { |element| "#{element.first}=#{element.last}" }.join('&')
+ end
+
+ def validate(config)
+ raise ArgumentError, 'must pass "config"' unless config
+ raise ArgumentError, 'must pass "config[:endpoint]"' unless config[:endpoint]
+ unless config[:endpoint].start_with?('http://') || config[:endpoint].start_with?('https://')
+ raise ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.'
+ end
+ raise ArgumentError, 'must pass "config[:api_version]"' unless config[:api_version]
+ raise ArgumentError, 'must pass "config[:access_key_id]"' unless config[:access_key_id]
+ raise ArgumentError, 'must pass "config[:access_key_secret]"' unless config[:access_key_secret]
+ end
+ end
+end