aliyunsdkcore 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c66f7b9d52d1d4018fcf7a7c1ab5e30642b7ad7136f119209e1703d8b529a9
-  data.tar.gz: ebe5ab5cc9d7be04ecdb1b14985d90054041943cf68825b97a046e0aca4e0402
+  metadata.gz: 32c52b1b01cf9802096c014e087477c1082bd5bd541e132444b35f69036e7572
+  data.tar.gz: aea3c6a0f3701aa6c54752143216d98926666e790e73bcff75487cf83e8bdd39
 SHA512:
-  metadata.gz: cdf0d90f0e936a2fd34ece59b8699bc0ab628f09daf9fd75af29ab8db8b52ec6d018dc09f834326132db54665eaeece67cb9de60485f427dcf5316dd076d5c80
-  data.tar.gz: 7f54b1754aa69036f777802c6b10e4de55b682858f59987699561c687c9d34f3a9a8aee35735bd513b794529b5a6f598af400d2409505ec7222bfd23e7853ed2
+  metadata.gz: 1f2ccb9b12db0ed152ee3debea8e118b37651ea99388828661af992c6c9d35c31ea1d4ca3b1f268748b514f50f5296e6ae6a8a378baa897e082d73e8e3f6f3ff
+  data.tar.gz: 9203e79a4dc5d72cd11bb15f761674a0344617310de0e16ed16c26f63ee978983630def26cc921c0a49a694dfb7977c4a295f4cdf663b1dfd0b0c2d15a4bbc23

data/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

data/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

data/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"
+  VERSION = "0.0.8"
+  DEFAULT_UA = "AlibabaCloud (#{Gem::Platform.local.os}; " +
+    "#{Gem::Platform.local.cpu}) Ruby/#{RUBY_VERSION} Core/#{VERSION}"
 end
+
+RPCClient = AliyunSDKCore::RPCClient
+ROAClient = AliyunSDKCore::ROAClient

data/spec/roa_client_integration_spec.rb

@@ -1,10 +1,11 @@
 require 'rspec'
-require 'roa_client'
 require 'webmock/rspec'
 
+require 'aliyunsdkcore'
+
 describe 'roa request' do
 
-  WebMock.disable_net_connect!(allow: %r{ros.aliyuncs.com/regions})
+  WebMock.allow_net_connect!
 
   let(:roa_client) do
     ROAClient.new(
@@ -12,7 +13,7 @@ describe 'roa request' do
       api_version:       '2015-09-01',
       access_key_id:     ENV['ACCESS_KEY_ID'],
       access_key_secret: ENV['ACCESS_KEY_SECRET'],
-      )
+    )
   end
 
   it 'request' do

data/spec/roa_client_spec.rb

@@ -1,273 +1,279 @@
 require 'rspec'
-require 'roa_client'
 require 'webmock/rspec'
 
-describe 'roa core' do
+require "aliyunsdkcore"
 
-  it 'should pass into "config"' do
-    expect {
-      ROAClient.new(nil)
-    }.to raise_error(ArgumentError, 'must pass "config"')
-  end
-
-  it 'should pass into "config[:endpoint]"' do
-    expect {
-      ROAClient.new({})
-    }.to raise_error(ArgumentError, 'must pass "config[:endpoint]"')
-  end
-
-  it 'should pass into valid "config[:endpoint]"' do
-    expect {
-      ROAClient.new(endpoint: 'ecs.aliyuncs.com/')
-    }.to raise_error(ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.')
-  end
+describe 'ROAClient' do
 
-  it 'should pass into "config[:api_version]"' do
-    expect {
-      ROAClient.new(endpoint: 'http://ecs.aliyuncs.com/')
-    }.to raise_error(ArgumentError, 'must pass "config[:api_version]"')
-  end
+  describe 'initialize' do
 
-  it 'should pass into "config[:access_key_id]"' do
-    expect {
-      ROAClient.new(endpoint: 'http://ecs.aliyuncs.com/', api_version: '1.0')
-    }.to raise_error(ArgumentError, 'must pass "config[:access_key_id]"')
-  end
+    it 'should pass into "config"' do
+      expect {
+        ROAClient.new(nil)
+      }.to raise_error(ArgumentError, 'must pass "config"')
+    end
 
-  it 'should pass into "config[:access_key_secret]"' do
-    expect {
-      ROAClient.new(endpoint: 'http://ecs.aliyuncs.com/', api_version: '1.0', access_key_id: 'access_key_id')
-    }.to raise_error(ArgumentError, 'must pass "config[:access_key_secret]"')
-  end
+    it 'should pass into "config[:endpoint]"' do
+      expect {
+        ROAClient.new({})
+      }.to raise_error(ArgumentError, 'must pass "config[:endpoint]"')
+    end
 
-  it 'should ok with http protocol' do
-    roa_client = ROAClient.new(
-      endpoint:          'http://ecs.aliyuncs.com/',
-      api_version:       '1.0',
-      access_key_id:     'access_key_id',
-      access_key_secret: 'access_key_secret'
-    )
-    expect(roa_client.endpoint).to eq('http://ecs.aliyuncs.com/')
-  end
+    it 'should pass into valid "config[:endpoint]"' do
+      expect {
+        ROAClient.new(endpoint: 'ros.aliyuncs.com/')
+      }.to raise_error(ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.')
+    end
 
-  it 'should ok with https protocol' do
-    roa_client = ROAClient.new(
-      endpoint:          'https://ecs.aliyuncs.com/',
-      api_version:       '1.0',
-      access_key_id:     'access_key_id',
-      access_key_secret: 'access_key_secret'
-    )
-    expect(roa_client.endpoint).to eq('https://ecs.aliyuncs.com/')
-  end
+    it 'should pass into "config[:api_version]"' do
+      expect {
+        ROAClient.new(endpoint: 'http://ros.aliyuncs.com/')
+      }.to raise_error(ArgumentError, 'must pass "config[:api_version]"')
+    end
 
-  let(:roa_client) do
-    ROAClient.new(
-      endpoint:          'https://ecs.aliyuncs.com/',
-      api_version:       '1.0',
-      access_key_id:     'access_key_id',
-      access_key_secret: 'access_key_secret'
-    )
-  end
+    it 'should pass into "config[:access_key_id]"' do
+      expect {
+        ROAClient.new(endpoint: 'http://ros.aliyuncs.com/', api_version: '1.0')
+      }.to raise_error(ArgumentError, 'must pass "config[:access_key_id]"')
+    end
 
-  let(:default_header_keys) do
-    %w(accept date host
-        x-acs-signature-nonce
-        x-acs-signature-method
-        x-acs-signature-version
-        x-acs-version
-        x-sdk-client).map(&:to_sym)
-  end
+    it 'should pass into "config[:access_key_secret]"' do
+      expect {
+        ROAClient.new(endpoint: 'http://ros.aliyuncs.com/', api_version: '1.0', access_key_id: 'access_key_id')
+      }.to raise_error(ArgumentError, 'must pass "config[:access_key_secret]"')
+    end
 
-  it 'default headers should ok' do
-    expect(roa_client.default_headers.keys).to match_array(default_header_keys)
-    expect(roa_client.default_headers[:accept]).to eq('application/json')
-    expect(roa_client.default_headers[:date]).to match(/[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT/)
-    expect(roa_client.default_headers[:host]).to eq('ecs.aliyuncs.com')
-  end
+    it 'should ok with http protocol' do
+      roa_client = ROAClient.new(
+        endpoint:          'http://ros.aliyuncs.com/',
+        api_version:       '1.0',
+        access_key_id:     'access_key_id',
+        access_key_secret: 'access_key_secret'
+      )
+      expect(roa_client.endpoint).to eq('http://ros.aliyuncs.com/')
+    end
 
-  it 'default_headers should ok with security_token' do
-
-    roa_client = ROAClient.new(
-      endpoint:          'https://ecs.aliyuncs.com/',
-      api_version:       '1.0',
-      access_key_id:     'access_key_id',
-      access_key_secret: 'access_key_secret',
-      security_token:    'security_token'
-    )
-
-    default_header_keys = %w(
-      accept
-      date
-      host
-      x-acs-signature-nonce
-      x-acs-signature-method
-      x-acs-signature-version
-      x-acs-version
-      x-sdk-client
-      x-acs-accesskey-id
-      x-acs-security-token
-    ).map(&:to_sym)
-
-    expect(roa_client.default_headers[:accept]).to eq('application/json')
-    expect(roa_client.default_headers.keys).to match_array(default_header_keys)
-    expect(roa_client.default_headers[:date]).to match(/[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT/)
-    expect(roa_client.default_headers[:accept]).to eq('application/json')
-  end
+    it 'should ok with https protocol' do
+      roa_client = ROAClient.new(
+        endpoint:          'https://ros.aliyuncs.com/',
+        api_version:       '1.0',
+        access_key_id:     'access_key_id',
+        access_key_secret: 'access_key_secret'
+      )
+      expect(roa_client.endpoint).to eq('https://ros.aliyuncs.com/')
+    end
 
-  describe 'request with json response should ok' do
-    it 'json response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: 200, headers: { 'Content-Type': 'application/json' }, body: { ok: true }.to_json)
-      response = roa_client.get(uri: '/')
-      expect(response.body).to eq({ ok: true }.to_json)
+    let(:roa_client) do
+      ROAClient.new(
+        endpoint:          'https://ros.aliyuncs.com/',
+        api_version:       '1.0',
+        access_key_id:     'access_key_id',
+        access_key_secret: 'access_key_secret'
+      )
     end
-  end
 
-  describe 'request(204) with json response should ok' do
-    it 'json response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: 204, headers: { 'Content-Type': 'application/json' }, body: '')
-      response = roa_client.get(uri: '/')
-      expect(response.body).to eq('')
+    let(:default_header_keys) do
+      %w(accept date host
+          x-acs-signature-nonce
+          x-acs-signature-method
+          x-acs-signature-version
+          x-acs-version
+          x-sdk-client
+          user-agent)
     end
-  end
 
-  describe 'request(400) with json response should ok' do
-    let(:status) { 400 }
-    let(:headers) { { 'Content-Type': 'application/json' } }
-    let(:body) { { 'Message': 'error message', 'RequestId': 'requestid', 'Code': 'errorcode' }.to_json }
-    it 'json response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: status, headers: headers, body: body)
-      expect {
-        roa_client.get(uri: '/')
-      }.to raise_error(StandardError, 'code: 400, error message requestid: requestid')
+    it 'default headers should ok' do
+      expect(roa_client.default_headers.keys).to match_array(default_header_keys)
+      expect(roa_client.default_headers['accept']).to eq('application/json')
+      expect(roa_client.default_headers['date']).to match(/[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT/)
+      expect(roa_client.default_headers['host']).to eq('ros.aliyuncs.com')
+      expect(roa_client.default_headers['user-agent']).to match(/AlibabaCloud \(.*; .*\) Ruby\/\d+.\d+.\d+ Core\/\d+.\d+.\d+/)
     end
-  end
 
-  describe 'request with xml response should ok' do
-    let(:status) { 200 }
-    let(:headers) { { 'Content-Type': 'text/xml' } }
-    let(:body) do
-      <<-XML
-        <note>
-          <to>George</to>
-          <from>John</from>
-          <heading>Reminder</heading>
-          <body>Don't forget the meeting!</body>
-        </note>
-      XML
+    it 'default_headers should ok with security_token' do
+      roa_client = ROAClient.new(
+        endpoint:          'https://ros.aliyuncs.com/',
+        api_version:       '1.0',
+        access_key_id:     'access_key_id',
+        access_key_secret: 'access_key_secret',
+        security_token:    'security_token'
+      )
+
+      default_header_keys = %w(
+        accept
+        date
+        host
+        x-acs-signature-nonce
+        x-acs-signature-method
+        x-acs-signature-version
+        x-acs-version
+        x-sdk-client
+        x-acs-accesskey-id
+        x-acs-security-token
+        user-agent
+      )
+
+      expect(roa_client.default_headers['accept']).to eq('application/json')
+      expect(roa_client.default_headers.keys).to match_array(default_header_keys)
+      expect(roa_client.default_headers['date']).to match(/[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT/)
+      expect(roa_client.default_headers['accept']).to eq('application/json')
+      expect(roa_client.default_headers['user-agent']).to match(/AlibabaCloud \(.*; .*\) Ruby\/\d+.\d+.\d+ Core\/\d+.\d+.\d+/)
     end
-    it 'xml response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: status, headers: headers, body: body)
-      response = roa_client.get(uri: '/')
-      expect(response.body).to eq(body)
+
+    describe 'request with json response should ok' do
+      it 'json response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: 200, headers: { 'Content-Type': 'application/json' }, body: { ok: true }.to_json)
+        response = roa_client.get(uri: '/')
+        expect(response.body).to eq({ ok: true }.to_json)
+      end
     end
-  end
 
-  describe 'request(400) with xml response should ok' do
-    let(:status) { 400 }
-    let(:headers) { { 'Content-Type': 'text/xml' } }
-    let(:body) do
-      <<-XML
-        <Error>
-          <Message>error message</Message>
-          <RequestId>requestid</RequestId>
-          <HostId>hostid</HostId>
-          <Code>errorcode</Code>
-        </Error>
-      XML
+    describe 'request(204) with json response should ok' do
+      it 'json response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: 204, headers: { 'Content-Type': 'application/json' }, body: '')
+        response = roa_client.get(uri: '/')
+        expect(response.body).to eq('')
+      end
     end
-    it 'xml response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: status, headers: headers, body: body)
-      expect {
-        roa_client.get(uri: '/')
-      }.to raise_error(ROAClient::ACSError, 'error message host_id: hostid, request_id: requestid')
+
+    describe 'request(400) with json response should ok' do
+      let(:status) { 400 }
+      let(:headers) { { 'Content-Type': 'application/json' } }
+      let(:body) { { 'Message': 'error message', 'RequestId': 'requestid', 'Code': 'errorcode' }.to_json }
+      it 'json response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: status, headers: headers, body: body)
+        expect {
+          roa_client.get(uri: '/')
+        }.to raise_error(StandardError, 'code: 400, error message requestid: requestid')
+      end
     end
-  end
 
-  describe 'request(200) with plain response should ok' do
-    it 'plain response should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/").to_return(status: 200, body: 'plain text')
-      response = roa_client.get(uri: '/')
-      expect(response.body).to eq('plain text')
+    describe 'request with xml response should ok' do
+      let(:status) { 200 }
+      let(:headers) { { 'Content-Type': 'text/xml' } }
+      let(:body) do
+        <<-XML
+          <note>
+            <to>George</to>
+            <from>John</from>
+            <heading>Reminder</heading>
+            <body>Don't forget the meeting!</body>
+          </note>
+        XML
+      end
+      it 'xml response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: status, headers: headers, body: body)
+        response = roa_client.get(uri: '/')
+        expect(response.body).to eq(body)
+      end
     end
-  end
 
-  describe 'post should ok' do
-    it 'should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
-      response = roa_client.post(uri: '/', body: 'text')
-      expect(response.body).to eq('{"ok":true}')
+    describe 'request(400) with xml response should ok' do
+      let(:status) { 400 }
+      let(:headers) { { 'Content-Type': 'text/xml' } }
+      let(:body) do
+        <<-XML
+          <Error>
+            <Message>error message</Message>
+            <RequestId>requestid</RequestId>
+            <HostId>hostid</HostId>
+            <Code>errorcode</Code>
+          </Error>
+        XML
+      end
+      it 'xml response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: status, headers: headers, body: body)
+        expect {
+          roa_client.get(uri: '/')
+        }.to raise_error(ROAClient::ACSError, 'error message host_id: hostid, request_id: requestid')
+      end
     end
-    it 'should ok with query' do
-      stub_request(:get, "https://ecs.aliyuncs.com/?k=v")
-        .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
-      response = roa_client.post(uri: '/', params: { k: 'v' }, body: 'text')
-      expect(response.body).to eq('{"ok":true}')
+
+    describe 'request(200) with plain response should ok' do
+      it 'plain response should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/").to_return(status: 200, body: 'plain text')
+        response = roa_client.get(uri: '/')
+        expect(response.body).to eq('plain text')
+      end
     end
-  end
 
-  describe 'put should ok' do
-    it 'should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
-      response = roa_client.put(uri: '/', body: 'text')
-      expect(response.body).to eq('{"ok":true}')
+    describe 'post should ok' do
+      it 'should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
+        response = roa_client.post(uri: '/', body: 'text')
+        expect(response.body).to eq('{"ok":true}')
+      end
+      it 'should ok with query' do
+        stub_request(:get, "https://ros.aliyuncs.com/?k=v")
+          .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
+        response = roa_client.post(uri: '/', params: { k: 'v' }, body: 'text')
+        expect(response.body).to eq('{"ok":true}')
+      end
     end
-  end
 
-  describe 'delete should ok' do
-    it 'should ok' do
-      stub_request(:get, "https://ecs.aliyuncs.com/")
-        .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
-      response = roa_client.delete(uri: '/')
-      expect(response.body).to eq('{"ok":true}')
+    describe 'put should ok' do
+      it 'should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
+        response = roa_client.put(uri: '/', body: 'text')
+        expect(response.body).to eq('{"ok":true}')
+      end
     end
-  end
 
-  it 'signature should ok' do
-    expect(roa_client.send(:signature, '123456')).to eq('BeAYlq/e5iWAoTNmzf8jbcBxdq0=')
-  end
+    describe 'delete should ok' do
+      it 'should ok' do
+        stub_request(:get, "https://ros.aliyuncs.com/")
+          .to_return(status: 200, headers: { 'content-type': 'application/json' }, body: { ok: true }.to_json)
+        response = roa_client.delete(uri: '/')
+        expect(response.body).to eq('{"ok":true}')
+      end
+    end
 
-  it 'authorization should ok' do
-    expect(roa_client.send(:authorization, '123456')).to eq('acs access_key_id:BeAYlq/e5iWAoTNmzf8jbcBxdq0=')
-  end
+    it 'signature should ok' do
+      expect(roa_client.send(:signature, '123456')).to eq('BeAYlq/e5iWAoTNmzf8jbcBxdq0=')
+    end
 
-  it 'canonicalized_headers should ok' do
-    expect(roa_client.send(:canonicalized_headers, {})).to be_empty
-    expect(roa_client.send(:canonicalized_headers, { key: 'value' })).to be_empty
-    expect(roa_client.send(:canonicalized_headers, { 'x-acs-key': 'value' })).to eq("x-acs-key:value\n")
-  end
+    it 'authorization should ok' do
+      expect(roa_client.send(:authorization, '123456')).to eq('acs access_key_id:BeAYlq/e5iWAoTNmzf8jbcBxdq0=')
+    end
 
-  it 'canonicalized_resource should ok' do
-    expect(roa_client.send(:canonicalized_resource, '/')).to eq('/')
-    expect(roa_client.send(:canonicalized_resource, '/', { key: 'value' })).to eq('/?key=value')
-    expect(roa_client.send(:canonicalized_resource, '/', { key: 'value', 'key1': 'value2' })).to eq('/?key=value&key1=value2')
-  end
+    it 'canonicalized_headers should ok' do
+      expect(roa_client.send(:canonicalized_headers, {})).to be_empty
+      expect(roa_client.send(:canonicalized_headers, { key: 'value' })).to be_empty
+      expect(roa_client.send(:canonicalized_headers, { 'x-acs-key': 'value' })).to eq("x-acs-key:value\n")
+    end
 
-  it 'string_to_sign should ok ' do
-    expect(
-      roa_client.send(:string_to_sign, 'GET', '/', { 'accept' => 'application/json' })
-    ).to eq("GET\napplication/json\n\n\n\n/")
-  end
+    it 'canonicalized_resource should ok' do
+      expect(roa_client.send(:canonicalized_resource, '/')).to eq('/')
+      expect(roa_client.send(:canonicalized_resource, '/', { key: 'value' })).to eq('/?key=value')
+      expect(roa_client.send(:canonicalized_resource, '/', { key: 'value', 'key1': 'value2' })).to eq('/?key=value&key1=value2')
+    end
 
-  describe 'ROAClient::ACSError class' do
-    it 'ACSError should ok' do
-      expect {
-        error_info = {
-          'Message' =>   'error message',
-          'Code' =>     'errorcode',
-          'HostId' =>    'hostid',
-          'RequestId' => 'requestid',
-        }
-        raise ROAClient::ACSError, error_info
-      }.to raise_error(ROAClient::ACSError, 'error message host_id: hostid, request_id: requestid')
+    it 'string_to_sign should ok ' do
+      expect(
+        roa_client.send(:string_to_sign, 'GET', '/', { 'accept' => 'application/json' })
+      ).to eq("GET\napplication/json\n\n\n\n/")
     end
-  end
 
+    describe 'ROAClient::ACSError class' do
+      it 'ACSError should ok' do
+        expect {
+          error_info = {
+            'Message' =>   'error message',
+            'Code' =>      'errorcode',
+            'HostId' =>    'hostid',
+            'RequestId' => 'requestid',
+          }
+          raise ROAClient::ACSError, error_info
+        }.to raise_error(ROAClient::ACSError, 'error message host_id: hostid, request_id: requestid')
+      end
+    end
 
+  end
 end

data/spec/rpc_client_integration_spec.rb

@@ -1,10 +1,11 @@
 require 'rspec'
-require 'rpc_client'
 require 'webmock/rspec'
 
+require "aliyunsdkcore"
+
 describe 'rpc request' do
 
-  WebMock.disable_net_connect!(allow: %r{ecs.aliyuncs.com})
+  WebMock.allow_net_connect!
 
   let(:rpc_client) do
     RPCClient.new(

data/spec/rpc_client_spec.rb

@@ -1,10 +1,11 @@
 require 'rspec'
-require 'rpc_client'
 require 'webmock/rspec'
 
-describe 'rpc core' do
+require "aliyunsdkcore"
 
-  describe 'RPCClient' do
+describe 'RPCClient' do
+
+  describe 'initialize' do
     it 'should pass into "config"' do
       expect {
         RPCClient.new(nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aliyunsdkcore
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Alibaba Cloud SDK
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-05 00:00:00.000000000 Z
+date: 2019-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.16.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.8.0
 - !ruby/object:Gem::Dependency
   name: codecov
   requirement: !ruby/object:Gem::Requirement
@@ -89,8 +89,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/aliyunsdkcore.rb
-- lib/roa_client.rb
-- lib/rpc_client.rb
+- lib/aliyunsdkcore/roa_client.rb
+- lib/aliyunsdkcore/rpc_client.rb
 - spec/roa_client_integration_spec.rb
 - spec/roa_client_spec.rb
 - spec/rpc_client_integration_spec.rb

data/lib/roa_client.rb

@@ -1,153 +0,0 @@
-require 'faraday'
-require 'securerandom'
-require 'active_support/all'
-
-def present?(obj)
-  obj.respond_to?(:empty?) ? !obj.empty? : obj
-end
-
-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
-      string_to_sign = string_to_sign(method, uri, mix_headers, params)
-      mix_headers.merge!(authorization: authorization(string_to_sign))
-      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的名称和版本号
-    }
-    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

data/lib/rpc_client.rb

@@ -1,141 +0,0 @@
-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
-
-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|
-      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