aliyun-rails 0.1.17 → 0.1.20

data/lib/aliyun/connector/roa_client.rb

@@ -1,166 +1,166 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "securerandom"
-require "active_support/all"
-require "net/http"
-
-module Net::HTTPHeader
-  def capitalize(name)
-    name
-  end
-  private :capitalize
-end
-
-module Aliyun
-  module Connector
-    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] || Aliyun.access_key_id
-        self.access_key_secret = config[:access_key_secret] || Aliyun.access_key_secret
-        self.security_token    = config[:security_token]
-      end
-
-      def request(method:, uri:, params: {}, body: {}, headers: {}, options: {})
-        # :"Content-Type" => "application/json" to "content-type" => "application/json"
-        headers.deep_transform_keys! { |key| key.to_s.downcase }
-        mix_headers = default_headers.merge(headers)
-
-        response = connection.send(method.downcase) do |request|
-          request.url uri, params
-          if body
-            if mix_headers["content-type"].start_with? "application/json"
-              request_body = body.to_json
-            elsif mix_headers["content-type"].start_with? "application/x-www-form-urlencoded"
-              request_body = URI.encode_www_form(body)
-            else
-              request_body = body
-            end
-            mix_headers["content-md5"]    = Digest::MD5.base64digest request_body
-            mix_headers["content-length"] = request_body.length.to_s
-            request.body                  = request_body
-          end
-          string2sign                 = string_to_sign(method, uri, mix_headers, params)
-          mix_headers[: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) { |f| f.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: :post, uri: uri, params: params, body: body, headers: headers, options: options)
-      end
-
-      def put(uri: "", headers: {}, params: {}, body: {}, options: {})
-        request(method: :put, uri: uri, params: params, body: body, headers: headers, options: options)
-      end
-
-      def delete(uri: "", headers: {}, params: {}, options: {})
-        request(method: :delete, 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["x-acs-accesskey-id"]   = self.access_key_id
-          default_headers["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.sort.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
-end
+# frozen_string_literal: true
+
+require "faraday"
+require "securerandom"
+require "active_support/all"
+require "net/http"
+
+module Net::HTTPHeader
+  def capitalize(name)
+    name
+  end
+  private :capitalize
+end
+
+module Aliyun
+  module Connector
+    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: {})
+        # :"Content-Type" => "application/json" to "content-type" => "application/json"
+        headers.deep_transform_keys! { |key| key.to_s.downcase }
+        mix_headers = default_headers.merge(headers)
+
+        response = connection.send(method.downcase) do |request|
+          request.url uri, params
+          if body
+            if mix_headers["content-type"].start_with? "application/json"
+              request_body = body.to_json
+            elsif mix_headers["content-type"].start_with? "application/x-www-form-urlencoded"
+              request_body = URI.encode_www_form(body)
+            else
+              request_body = body
+            end
+            mix_headers["content-md5"]    = Digest::MD5.base64digest request_body
+            mix_headers["content-length"] = request_body.length.to_s
+            request.body                  = request_body
+          end
+          string2sign                 = string_to_sign(method, uri, mix_headers, params)
+          mix_headers[: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) { |f| f.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: :post, uri: uri, params: params, body: body, headers: headers, options: options)
+      end
+
+      def put(uri: "", headers: {}, params: {}, body: {}, options: {})
+        request(method: :put, uri: uri, params: params, body: body, headers: headers, options: options)
+      end
+
+      def delete(uri: "", headers: {}, params: {}, options: {})
+        request(method: :delete, 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["x-acs-accesskey-id"]   = self.access_key_id
+          default_headers["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.sort.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
+end

data/lib/aliyun/connector/rpc_client.rb

@@ -1,116 +1,148 @@
-# frozen_string_literal: true
-
-require "set"
-require "openssl"
-require "faraday"
-require "erb"
-require "active_support/all"
-
-module Aliyun
-  module Connector
-    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] || Aliyun.access_key_id
-        self.access_key_secret = config[:access_key_secret] || Aliyun.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              = action.upcase_first 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
-        sign                = "#{method}&#{encode('/')}&#{encode(params.to_query)}"
-        secret              = "#{self.access_key_secret}&"
-        signature           = Base64.encode64(OpenSSL::HMAC.digest("sha1", secret, sign)).strip
-        params["Signature"] = signature
-
-        # 转换为 query 样式
-        query_string = params.to_query
-
-        # 特殊处理 POST
-        uri = opts[:method] == "POST" ? "/" : "/?#{query_string}"
-
-        # 初始化会话
-        response = connection.send(method.downcase, uri) do |r|
-          if opts[:method] == "POST"
-            r.headers["Content-Type"] = "application/x-www-form-urlencoded"
-            r.body                    = query_string
-          end
-          r.headers["User-Agent"] = DEFAULT_UA
-        end
-
-        # 解析接口响应
-        response_body = JSON.parse(response.body)
-        if response_body["Code"] && !response_body["Code"].to_s.empty? && !self.codes.include?(response_body["Code"])
-          raise StandardError, "Code: #{response_body['Code']}, Message: #{response_body['Message']}, URL: #{uri}"
-        end
-
-        response_body
-      end
-
-      private
-        def connection(adapter = Faraday.default_adapter)
-          Faraday.new(url: self.endpoint) { |f| f.adapter adapter }
-        end
-
-        # 设置缺省参数
-        def default_params
-          params                 = {
-            Format:           "JSON",
-            SignatureMethod:  "HMAC-SHA1",
-            SignatureNonce:   SecureRandom.hex(8),
-            SignatureVersion: "1.0",
-            Timestamp:        Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            AccessKeyId:      self.access_key_id,
-            Version:          self.api_version,
-          }
-          params[:SecurityToken] = self.security_token if self.security_token.present?
-          params
-        end
-
-        # 消息签名需要
-        def encode(input)
-          ERB::Util.url_encode input
-        end
-
-        # 转换 HASH key 样式
-        def format_params(param_hash)
-          param_hash.keys.each { |key| param_hash[(key.to_s.upcase_first).to_sym] = param_hash.delete key }
-          param_hash
-        end
-
-        def validate(config = {})
-          config.with_indifferent_access
-          raise ArgumentError, 'must pass "config"' unless config
-          raise ArgumentError, 'must pass "config[:endpoint]"' unless config[:endpoint]
-          unless config[:endpoint].match?(/^http[s]?:/i)
-            raise ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.'
-          end
-          raise ArgumentError, 'must pass "config[:api_version]"' unless config[:api_version]
-          unless config[:access_key_id] || Aliyun.access_key_id
-            raise ArgumentError, 'must pass "config[:access_key_id]" or define "Aliyun.access_key_id"'
-          end
-          unless config[:access_key_secret] || Aliyun.access_key_secret
-            raise ArgumentError, 'must pass "config[:access_key_secret]" or define "Aliyun.access_key_secret"'
-          end
-        end
-    end
-  end
-end
+require "set"
+require "openssl"
+require "faraday"
+require "active_support/all"
+
+module Aliyun
+  module Connector
+    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] || Aliyun.access_key_id
+        self.access_key_secret = config[:access_key_secret] || Aliyun.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         = action.upcase_first 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)}"
+        secret         = "#{self.access_key_secret}&"
+        signature      = Base64.encode64(OpenSSL::HMAC.digest("sha1", secret, string_to_sign)).strip
+        normalized.push(["Signature", encode(signature)])
+
+        # 转换为 query 样式
+        querystring = canonicalize(normalized)
+
+        # 特殊处理 POST
+        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
+          request.headers["User-Agent"] = DEFAULT_UA
+        end
+
+        # 解析接口响应
+        response_body = JSON.parse(response.body)
+        if response_body["Code"] && !response_body["Code"].to_s.empty? && !self.codes.include?(response_body["Code"])
+          raise StandardError, "Code: #{response_body['Code']}, Message: #{response_body['Message']}, URL: #{uri}"
+        end
+
+        response_body
+      end
+
+      private
+        def connection(adapter = Faraday.default_adapter)
+          Faraday.new(url: self.endpoint) { |f| f.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["SecurityToken"] = self.security_token if self.security_token
+          default_params
+        end
+
+        # 消息签名需要
+        def encode(string)
+          ERB::Util.url_encode(string)
+        end
+
+        # 转换 HASH key 样式
+        def format_params(param_hash)
+          param_hash.keys.each { |key| param_hash[(key.to_s.upcase_first).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 = {})
+          config.with_indifferent_access
+          raise ArgumentError, 'must pass "config"' unless config
+          raise ArgumentError, 'must pass "config[:endpoint]"' unless config[:endpoint]
+          unless config[:endpoint].match?(/^http[s]?:/i)
+            raise ArgumentError, '"config.endpoint" must starts with \'https://\' or \'http://\'.'
+          end
+          raise ArgumentError, 'must pass "config[:api_version]"' unless config[:api_version]
+          unless config[:access_key_id] || Aliyun.access_key_id
+            raise ArgumentError, 'must pass "config[:access_key_id]" or define "Aliyun.access_key_id"'
+          end
+          unless config[:access_key_secret] || Aliyun.access_key_secret
+            raise ArgumentError, 'must pass "config[:access_key_secret]" or define "Aliyun.access_key_secret"'
+          end
+        end
+    end
+  end
+end

data/lib/aliyun/dysms.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module Aliyun
-  class Dysms < Aliyun::Connector::RPCClient
-    # 本产品（Dysmsapi/2017-05-25）的OpenAPI采用RPC签名风格，签名细节参见签名机制说明。
-    # 我们已经为开发者封装了常见编程语言的SDK，开发者可通过下载SDK直接调用本产品OpenAPI而无需关心技术细节。
-    def initialize(config = {}, verbose = nil)
-      config[:endpoint]    ||= "http://dysmsapi.aliyuncs.com"
-      config[:api_version] ||= "2017-05-25"
-      super(config, verbose)
-    end
-
-    # 发送短信，发送前要申请短信签名和短信模板，并确保签名和模板已审核通过。
-    def send_sms(phone_numbers, template_code, template_param, sign_name = "")
-      params = {
-        PhoneNumbers:  phone_numbers,
-        SignName:      sign_name,
-        TemplateCode:  template_code,
-        TemplateParam: template_param.to_json
-      }
-      opts   = { method: "POST", timeout: 15000 }
-      request(action: "SendSms", params: params, opts: opts)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Aliyun
+  class Dysms < Aliyun::Connector::RPCClient
+    # 本产品（Dysmsapi/2017-05-25）的OpenAPI采用RPC签名风格，签名细节参见签名机制说明。
+    # 我们已经为开发者封装了常见编程语言的SDK，开发者可通过下载SDK直接调用本产品OpenAPI而无需关心技术细节。
+    def initialize(config = {}, verbose = nil)
+      config[:endpoint]    ||= "http://dysmsapi.aliyuncs.com"
+      config[:api_version] ||= "2017-05-25"
+      super(config, verbose)
+    end
+
+    # 发送短信，发送前要申请短信签名和短信模板，并确保签名和模板已审核通过。
+    def send_sms(phone_numbers, template_code, template_param, sign_name = "")
+      params = {
+        PhoneNumbers:  phone_numbers,
+        SignName:      sign_name,
+        TemplateCode:  template_code,
+        TemplateParam: template_param.to_json
+      }
+      opts   = { method: "POST", timeout: 15000 }
+      request(action: "SendSms", params: params, opts: opts)
+    end
+  end
+end