qiniu_jxb_fix 6.4.2

data/lib/qiniu/abstract.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+    module Abstract
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def abstract_methods(*args)
+          args.each do |name|
+            class_eval <<-END
+              def #{name}(*args)
+                errmsg = %Q(class \#{self.class.name} must implement abstract method #{self.name}##{name}().)
+                raise NotImplementedError.new(errmsg)
+              end
+            END
+          end
+        end
+      end
+    end # module Abstract
+end # module Qiniu

data/lib/qiniu/adt.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+require 'uri'
+
+module Qiniu
+  module ADT
+    
+    class ApiSpecification
+      public
+      def to_str; return ""; end
+    end # class ApiSpecification
+
+    module Policy
+      public
+      def to_json
+        args = {}
+
+        self.params.each_pair do |key, fld|
+          val = self.__send__(key)
+          if !val.nil? then
+            args[fld] = val
+          end
+        end
+
+        return args.to_json
+      end # to_json
+
+      def to_query_string
+        args = []
+
+        self.params.each_pair do |key, fld|
+          val = self.__send__(key)
+          if !val.nil? then
+            new_fld = CGI.escape(fld.to_s)
+            new_val = CGI.escape(val.to_s).gsub('+', '%20')
+            args.push("#{new_fld}=#{new_val}")
+          end
+        end
+
+        return args.join("&")
+      end # to_query_string
+    end # module Policy
+
+  end # module ADT
+end # module Qiniu

data/lib/qiniu/auth.rb

@@ -0,0 +1,255 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+require 'hmac-sha1'
+require 'uri'
+require 'cgi'
+
+require 'qiniu/exceptions'
+require 'qiniu/helper'
+
+module Qiniu
+    module Auth
+      extend Qiniu::Helper
+      DEFAULT_AUTH_SECONDS = 3600
+
+      class << self
+        def calculate_deadline(expires_in, deadline = nil)
+          ### 授权期计算
+          if expires_in.is_a?(Integer) && expires_in > 0 then
+            # 指定相对时间，单位：秒
+            return get_expire_time.to_i + expires_in
+          elsif deadline.is_a?(Integer) then
+            # 指定绝对时间，常用于调试和单元测试
+            return deadline
+          end
+
+          # 默认授权期1小时
+          return get_expire_time.to_i + DEFAULT_AUTH_SECONDS
+        end # calculate_deadline
+      end # class << self
+
+      class PutPolicy
+        private
+        def initialize(bucket,
+                       key = nil,
+                       expires_in = DEFAULT_AUTH_SECONDS,
+                       deadline = nil)
+          ### 设定scope参数（必填项目）
+          self.scope!(bucket, key)
+
+          ### 设定deadline参数（必填项目）
+          @expires_in = expires_in
+          @deadline   = Auth.calculate_deadline(expires_in, deadline)
+        end # initialize
+
+        PARAMS = {
+          # 字符串类型参数
+          :scope                  => "scope"               ,
+          :save_key               => "saveKey"             ,
+          :end_user               => "endUser"             ,
+          :return_url             => "returnUrl"           ,
+          :return_body            => "returnBody"          ,
+          :callback_url           => "callbackUrl"         ,
+          :callback_host          => "callbackHost"        ,
+          :callback_body          => "callbackBody"        ,
+          :callback_body_type     => "callbackBodyType"    ,
+          :persistent_ops         => "persistentOps"       ,
+          :persistent_notify_url  => "persistentNotifyUrl" ,
+          :persistent_pipeline    => "persistentPipeline"  ,
+
+          # 数值类型参数
+          :deadline               => "deadline"            ,
+          :insert_only            => "insertOnly"          ,
+          :fsize_limit            => "fsizeLimit"          ,
+          :callback_fetch_key     => "callbackFetchKey"    ,
+          :detect_mime            => "detectMime"          ,
+          :mime_limit             => "mimeLimit"
+        } # PARAMS
+
+        public
+        attr_reader :bucket, :key
+
+        def scope!(bucket, key = nil)
+          @bucket = bucket
+          @key    = key
+
+          if key.nil? then
+            # 新增语义，文件已存在则失败
+            @scope = bucket
+          else
+            # 覆盖语义，文件已存在则直接覆盖
+            @scope = "#{bucket}:#{key}"
+          end
+        end # scope!
+
+        def expires_in!(seconds)
+          if !seconds.nil? then
+            return @expires_in
+          end
+
+          @epires_in = seconds
+          @deadline  = Auth.calculate_deadline(seconds)
+
+          return @expires_in
+        end # expires_in!
+
+        def expires_in=(seconds)
+          return expires_in!(seconds)
+        end # expires_in=
+
+        def expires_in
+          return @expires_in
+        end # expires_in
+
+        def allow_mime_list! (list)
+          @mime_limit = list
+        end # allow_mime_list!
+
+        def deny_mime_list! (list)
+          @mime_limit = "!#{list}"
+        end # deny_mime_list!
+
+        def insert_only!
+          @insert_only = 1
+        end # insert_only!
+
+        def detect_mime!
+          @detect_mime = 1
+        end # detect_mime!
+
+        def to_json
+          args = {}
+
+          PARAMS.each_pair do |key, fld|
+            val = self.__send__(key)
+            if !val.nil? then
+              args[fld] = val
+            end
+          end
+
+          return args.to_json
+        end # to_json
+
+        PARAMS.each_pair do |key, fld|
+          attr_accessor key
+        end
+      end # class PutPolicy
+
+      class << self
+        EMPTY_ARGS = {}
+
+        ### 生成下载授权URL
+        def authorize_download_url(url, args = EMPTY_ARGS)
+          ### 提取AK/SK信息
+          access_key = Config.settings[:access_key]
+          secret_key = Config.settings[:secret_key]
+
+          download_url = url
+
+          ### URL变换：追加FOP指令
+          if args[:fop].is_a?(String) && args[:fop] != '' then
+            if download_url.index('?').is_a?(Fixnum) then
+              # 已有参数
+              download_url = "#{download_url}&#{args[:fop]}"
+            else
+              # 尚无参数
+              download_url = "#{download_url}?#{args[:fop]}"
+            end
+          end
+
+          ### 授权期计算
+          e = Auth.calculate_deadline(args[:expires_in], args[:deadline])
+
+          ### URL变换：追加授权期参数
+          if download_url.index('?').is_a?(Fixnum) then
+            # 已有参数
+            download_url = "#{download_url}&e=#{e}"
+          else
+            # 尚无参数
+            download_url = "#{download_url}?e=#{e}"
+          end
+
+          ### 生成数字签名
+          sign = HMAC::SHA1.new(secret_key).update(download_url).digest
+          encoded_sign = Utils.urlsafe_base64_encode(sign)
+
+          ### 生成下载授权凭证
+          dntoken = "#{access_key}:#{encoded_sign}"
+
+          ### 返回下载授权URL
+          return "#{download_url}&token=#{dntoken}"
+        end # authorize_download_url
+
+        ### 对包含中文或其它 utf-8 字符的 Key 做下载授权
+        def authorize_download_url_2(domain, key, args = EMPTY_ARGS)
+          url_encoded_key = CGI::escape(key)
+
+          schema = args[:schema] || "http"
+          port   = args[:port]
+
+          if port.nil? then
+            download_url = "#{schema}://#{domain}/#{url_encoded_key}"
+          else
+            download_url = "#{schema}://#{domain}:#{port}/#{url_encoded_key}"
+          end
+          return authorize_download_url(download_url, args)
+        end # authorize_download_url_2
+
+        def generate_acctoken(url, body = '')
+          ### 提取AK/SK信息
+          access_key = Config.settings[:access_key]
+          secret_key = Config.settings[:secret_key]
+
+          ### 解析URL，生成待签名字符串
+          uri = URI.parse(url)
+          signing_str = uri.path
+
+          # 如有QueryString部分，则需要加上
+          query_string = uri.query
+          if query_string.is_a?(String) && !query_string.empty?
+            signing_str += '?' + query_string
+          end
+
+          # 追加换行符
+          signing_str += "\n"
+
+          # 如果有Body，则也加上
+          # （仅限于mime == "application/x-www-form-urlencoded"的情况）
+          if body.is_a?(String) && !body.empty?
+              signing_str += body
+          end
+
+          ### 生成数字签名
+          sign = HMAC::SHA1.new(secret_key).update(signing_str).digest
+          encoded_sign = Utils.urlsafe_base64_encode(sign)
+
+          ### 生成管理授权凭证
+          acctoken = "#{access_key}:#{encoded_sign}"
+
+          ### 返回管理授权凭证
+          return acctoken
+        end # generate_acctoken
+
+        def generate_uptoken(put_policy)
+          ### 提取AK/SK信息
+          access_key = Config.settings[:access_key]
+          secret_key = Config.settings[:secret_key]
+
+          ### 生成待签名字符串
+          encoded_put_policy = Utils.urlsafe_base64_encode(put_policy.to_json)
+
+          ### 生成数字签名
+          sign = HMAC::SHA1.new(secret_key).update(encoded_put_policy).digest
+          encoded_sign = Utils.urlsafe_base64_encode(sign)
+
+          ### 生成上传授权凭证
+          uptoken = "#{access_key}:#{encoded_sign}:#{encoded_put_policy}"
+
+          ### 返回上传授权凭证
+          return uptoken
+        end # generate_uptoken
+      end # class << self
+
+    end # module Auth
+end # module Qiniu

data/lib/qiniu/config.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+#
+# USAGE WAY 1:
+# Qbox::Config.initialize_connect :client_id => "<ClientID>",
+#                                 :client_secret => "<ClientSecret>"
+#
+# USAGE WAY 2:
+# Qbox::Config.load "path/to/your_project/config/qiniu.yml"
+#
+
+require 'tmpdir'
+
+module Qiniu
+    module Config
+      class << self
+
+        DEFAULT_OPTIONS = {
+          :user_agent      => 'QiniuRuby/' + Version.to_s + ' ('+RUBY_PLATFORM+')' + ' Ruby/'+ RUBY_VERSION,
+          :method          => :post,
+          :content_type    => 'application/x-www-form-urlencoded',
+          :auth_url        => "https://acc.qbox.me/oauth2/token",
+          :rs_host         => "http://rs.qiniu.com",
+          :rsf_host        => "http://rsf.qbox.me",
+          :up_host         => "http://up.qiniu.com",
+          :pub_host        => "http://pu.qbox.me:10200",
+          :eu_host         => "http://eu.qbox.me",
+          :access_key      => "",
+          :secret_key      => "",
+          :auto_reconnect  => true,
+          :max_retry_times => 3,
+          :block_size      => 1024*1024*4,
+          :chunk_size      => 1024*256,
+          :enable_debug    => true,
+          :tmpdir          => Dir.tmpdir + File::SEPARATOR + 'QiniuRuby'
+        }
+
+        REQUIRED_OPTION_KEYS = [:access_key, :secret_key, :up_host]
+
+        attr_reader :settings, :default_params
+
+        def load config_file
+          if File.exist?(config_file)
+            config_options = YAML.load_file(config_file)
+            config_options.symbolize_keys!
+            initialize_connect(config_options)
+          else
+            raise MissingConfError, config_file
+          end
+        end
+
+        def initialize_connect options = {}
+          @settings = DEFAULT_OPTIONS.merge!(options)
+          REQUIRED_OPTION_KEYS.each do |opt|
+            raise MissingArgsError, [opt] unless @settings.has_key?(opt)
+          end
+        end
+
+      end
+    end # module Config
+end # module Qiniu

data/lib/qiniu/exceptions.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+
+    class Exception < RuntimeError
+    end
+
+    class ResponseError < Exception
+      attr_reader :response
+
+      def initialize(message, response = nil)
+        @response = response
+        super(message)
+      end
+
+      def http_code
+        @response.code.to_i if @response
+      end
+
+      def http_body
+        @response.body if @response
+      end
+
+      def inspect
+        "#{message}: #{http_body}"
+      end
+    end
+
+    class RequestFailed < ResponseError
+      def message
+        "HTTP status code: #{http_code}. Response body: #{http_body}"
+      end
+
+      def to_s
+        message
+      end
+    end
+
+    class UploadFailedError < Exception
+      def initialize(status_code, response_data)
+        data_string = response_data.map { |key, value| %Q(:#{key.to_s} => #{value.to_s}) }
+        msg = %Q(Uploading Failed. HTTP Status Code: #{status_code}. HTTP response body: #{data_string.join(', ')}.)
+        super(msg)
+      end
+    end
+
+    class FileSeekReadError < Exception
+      def initialize(fpath, block_index, seek_pos, read_length, result_length)
+        msg =  "Reading file: #{fpath}, "
+        msg += "at block index: #{block_index}. "
+        msg += "Expected seek_pos:#{seek_pos} and read_length:#{read_length}, "
+        msg += "but got result_length: #{result_length}."
+        super(msg)
+      end
+    end
+
+    class BlockSizeNotMathchError < Exception
+      def initialize(fpath, block_index, offset, restsize, block_size)
+        msg  = "Reading file: #{fpath}, "
+        msg += "at block index: #{block_index}. "
+        msg += "Expected offset: #{offset}, restsize: #{restsize} and block_size: #{block_size}, "
+        msg += "but got offset+restsize=#{offset+restsize}."
+        super(msg)
+      end
+    end
+
+    class BlockCountNotMathchError < Exception
+      def initialize(fpath, block_count, checksum_count, progress_count)
+        msg  = "Reading file: #{fpath}, "
+        msg += "Expected block_count, checksum_count, progress_count is: #{block_count}, "
+        msg += "but got checksum_count: #{checksum_count}, progress_count: #{progress_count}."
+        super(msg)
+      end
+    end
+
+    class MissingArgsError < Exception
+      def initialize(missing_keys)
+        key_list = missing_keys.map {|key| key.to_s}.join(' and the ')
+        super("You did not provide both required args. Please provide the #{key_list}.")
+      end
+    end
+
+    class MissingAccessToken < MissingArgsError
+      def initialize
+        super([:access_token])
+      end
+    end
+
+    class MissingRefreshToken < MissingArgsError
+      def initialize
+        super([:refresh_token])
+      end
+    end
+
+    class MissingUsernameOrPassword < MissingArgsError
+      def initialize
+        super([:username, :password])
+      end
+    end
+
+    class InvalidArgsError < Exception
+      def initialize(invalid_keys)
+        key_list = invalid_keys.map {|key| key.to_s}.join(' and the ')
+        super("#{key_list} should not be empty.")
+      end
+    end
+
+    class MissingConfError < Exception
+      def initialize(missing_conf_file)
+        super("Error, missing #{missing_conf_file}. You must have #{missing_conf_file} to configure your client id and secret.")
+      end
+    end
+
+    class NoSuchFileError < Exception
+      def initialize(missing_file)
+        super("Error, no such file #{missing_file}.")
+      end
+    end
+
+end # module Qiniu

data/lib/qiniu/fop.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+
+require 'qiniu/image'
+require 'qiniu/pfop'

data/lib/qiniu/http.rb

@@ -0,0 +1,137 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+module Qiniu
+  module HTTP
+
+    class << self
+      public
+      def is_response_ok?(http_code)
+          return 200 <= http_code && http_code <= 299
+      end # is_response_ok?
+
+      def generate_query_string(params)
+        if params.is_a?(Hash)
+          total_param = params.map { |key, value| %Q(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub('+', '%20')}) }
+          return total_param.join("&")
+        end
+
+        return params
+      end # generate_query_string
+
+      def get (url, opts = {})
+        ### 配置请求Header
+        req_headers = {
+          :connection => 'close',
+          :accept     => '*/*',
+          :user_agent => Config.settings[:user_agent]
+        }
+
+        # 优先使用外部Header，覆盖任何特定Header
+        if opts[:headers].is_a?(Hash) then
+          req_headers.merge!(opts[:headers])
+        end
+
+        ### 发送请求
+        response = RestClient.get(url, req_headers)
+        return response.code.to_i, response.body, response.raw_headers
+      rescue => e
+        Log.logger.warn "#{e.message} => Qiniu::HTTP.get('#{url}')"
+        if e.respond_to?(:response) && e.response.respond_to?(:code) then
+          return e.response.code, e.response.body, e.response.raw_headers
+        end
+        return nil, nil, nil
+      end # get
+
+      API_RESULT_MIMETYPE = 'application/json'
+
+      def api_get (url, opts = {})
+        ### 配置请求Header
+        headers = {
+          :accept => API_RESULT_MIMETYPE
+        }
+
+        # 将特定Header混入外部Header中
+        if opts[:headers].is_a?(Hash) then
+          opts[:headers] = opts[:headers].dup.merge!(headers)
+        else
+          opts[:headers] = headers
+        end
+
+        ### 发送请求，然后转换返回值
+        resp_code, resp_body, resp_headers = get(url, opts)
+        if resp_code.nil? then
+          return 0, {}, {}
+        end
+
+        content_type = resp_headers["content-type"][0]
+        if !content_type.nil? && content_type == API_RESULT_MIMETYPE then
+          # 如果是JSON格式，则反序列化
+          resp_body = Utils.safe_json_parse(resp_body)
+        end
+
+        return resp_code, resp_body, resp_headers
+      end # api_get
+
+      def post (url, req_body = nil, opts = {})
+        ### 配置请求Header
+        req_headers = {
+          :connection => 'close',
+          :accept     => '*/*',
+          :user_agent => Config.settings[:user_agent]
+        }
+
+        # 优先使用外部Header，覆盖任何特定Header
+        if opts[:headers].is_a?(Hash) then
+          req_headers.merge!(opts[:headers])
+        end
+
+        ### 发送请求
+        response = RestClient.post(url, req_body, req_headers)
+        return response.code.to_i, response.body, response.raw_headers
+      rescue => e
+        Log.logger.warn "#{e.message} => Qiniu::HTTP.post('#{url}')"
+        if e.respond_to?(:response) && e.response.respond_to?(:code) then
+          return e.response.code, e.response.body, e.response.raw_headers
+        end
+        return nil, nil, nil
+      end # post
+
+      def api_post (url, req_body = nil, opts = {})
+        ### 配置请求Header
+        headers = {
+          :accept => API_RESULT_MIMETYPE
+        }
+
+        # 将特定Header混入外部Header中
+        if opts[:headers].is_a?(Hash) then
+          opts[:headers] = opts[:headers].dup.merge!(headers)
+        else
+          opts[:headers] = headers
+        end
+
+        ### 发送请求，然后转换返回值
+        resp_code, resp_body, resp_headers = post(url, req_body, opts)
+        if resp_code.nil? then
+          return 0, {}, {}
+        end
+
+        content_type = resp_headers["content-type"][0]
+        if !content_type.nil? && content_type == API_RESULT_MIMETYPE then
+          # 如果是JSON格式，则反序列化
+          resp_body = Utils.safe_json_parse(resp_body)
+        end
+
+        return resp_code, resp_body, resp_headers
+      end # api_post
+
+      def management_post (url, body = '')
+        ### 授权并执行管理操作
+        return HTTP.api_post(url, body, {
+          :headers => { 'Authorization' => 'QBox ' + Auth.generate_acctoken(url, body) }
+        })
+      end # management_post
+    end # class << self
+
+  end # module HTTP
+end # module Qiniu

data/lib/qiniu/image.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module Fop
+    module Image
+      class << self
+        include Utils
+
+        def info(url)
+          return HTTP.api_get(url + '?imageInfo')
+        end # info
+
+        def exif(url)
+          return HTTP.api_get(url + '?exif')
+        end # exif
+
+        def mogrify_preview_url(source_image_url, options)
+          source_image_url + '?' + generate_mogrify_params_string(options)
+        end
+
+        def generate_mogrify_params_string(options = {})
+          opts = {}
+          options.each do |k, v|
+            opts[k.to_s] = v
+          end
+          params_string = ""
+          keys = ["thumbnail", "gravity", "crop", "quality", "rotate", "format"]
+          keys.each do |key|
+            params_string += %Q(/#{key}/#{opts[key]}) unless opts[key].nil?
+          end
+          params_string += '/auto-orient' unless opts["auto_orient"].nil?
+          'imageMogr' + URI.escape(params_string)
+        end
+
+      end
+    end # module Image
+  end # module Fop
+end # module Qiniu

data/lib/qiniu/log.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'
+
+module Qiniu
+    module Log
+      class << self
+        attr_accessor :logger
+
+        def logger
+          @logger ||= Logger.new(STDERR)
+        end
+      end
+    end # module Log
+end # module Qiniu