qiniu_jxb 6.2.4

data/lib/qiniu-rs.rb

@@ -0,0 +1,2 @@
+# More logical way to require 'qiniu-rs'
+require File.join(File.dirname(__FILE__), 'qiniu', 'qiniu')

data/lib/qiniu.rb

@@ -0,0 +1,209 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  autoload :Version, 'qiniu/version'
+  autoload :Utils, 'qiniu/utils'
+  autoload :Auth, 'qiniu/auth'
+  autoload :Config, 'qiniu/config'
+  autoload :Log, 'qiniu/log'
+  autoload :Exception, 'qiniu/exceptions'
+  autoload :AccessToken, 'qiniu/tokens/access_token'
+  autoload :QboxToken, 'qiniu/tokens/qbox_token'
+  autoload :UploadToken, 'qiniu/tokens/upload_token'
+  autoload :DownloadToken, 'qiniu/tokens/download_token'
+  autoload :Abstract, 'qiniu/abstract'
+  autoload :Storage, 'qiniu/storage'
+  autoload :Fop, 'qiniu/fop'
+  autoload :Misc, 'qiniu/misc'
+
+    class << self
+
+      StatusOK = 200
+
+      def establish_connection!(opts = {})
+        Config.initialize_connect opts
+      end
+
+      def mkbucket(bucket_name)
+        code, data = Storage.mkbucket(bucket_name)
+        code == StatusOK
+      end
+
+      def buckets
+        code, data = Storage.buckets
+        code == StatusOK ? data : false
+      end
+
+      def set_protected(bucket, protected_mode)
+        code, data = Misc.set_protected(bucket, protected_mode)
+        code == StatusOK
+      end
+
+      def set_separator(bucket, separator)
+        code, data = Misc.set_separator(bucket, separator)
+        code == StatusOK
+      end
+
+      def set_style(bucket, name, style)
+        code, data = Misc.set_style(bucket, name, style)
+        code == StatusOK
+      end
+
+      def unset_style(bucket, name)
+        code, data = Misc.unset_style(bucket, name)
+        code == StatusOK
+      end
+
+      def upload_file opts = {}
+        uncontained_opts = [:uptoken, :file, :bucket, :key] - opts.keys
+        raise MissingArgsError, uncontained_opts unless uncontained_opts.empty?
+
+        source_file = opts[:file]
+        raise NoSuchFileError, source_file unless File.exist?(source_file)
+
+        opts[:enable_resumable_upload] = true unless opts.has_key?(:enable_resumable_upload)
+
+        if opts[:enable_resumable_upload] && File::size(source_file) > Config.settings[:block_size]
+          code, data, raw_headers = Storage.upload_with_token(opts[:uptoken],
+                                            opts[:file],
+                                            opts[:bucket],
+                                            opts[:key],
+                                            opts[:mime_type],
+                                            opts[:note],
+                                            opts[:customer],
+                                            opts[:callback_params],
+                                            opts[:rotate])
+        else
+          code, data, raw_headers = Storage.upload_with_token(opts[:uptoken],
+                                            opts[:file],
+                                            opts[:bucket],
+                                            opts[:key],
+                                            opts[:mime_type],
+                                            opts[:note],
+                                            opts[:callback_params],
+                                            opts[:enable_crc32_check],
+                                            opts[:rotate])
+        end
+        raise UploadFailedError.new(code, data) if code != StatusOK
+        return data
+      end
+
+      def stat(bucket, key)
+        code, data = Storage.stat(bucket, key)
+        code == StatusOK ? data : false
+      end
+
+      def get(bucket, key, save_as = nil, expires_in = nil, version = nil)
+        code, data = Storage.get(bucket, key, save_as, expires_in, version)
+        code == StatusOK ? data : false
+      end
+
+      def download(bucket, key, save_as = nil, expires_in = nil, version = nil)
+        code, data = Storage.get(bucket, key, save_as, expires_in, version)
+        code == StatusOK ? data["url"] : false
+      end
+
+      def copy(source_bucket, source_key, target_bucket, target_key)
+        code, data = Storage.copy(source_bucket, source_key, target_bucket, target_key)
+        code == StatusOK
+      end
+
+      def move(source_bucket, source_key, target_bucket, target_key)
+        code, data = Storage.move(source_bucket, source_key, target_bucket, target_key)
+        code == StatusOK
+      end
+
+      def delete(bucket, key)
+        code, data = Storage.delete(bucket, key)
+        code == StatusOK
+      end
+
+      def batch(command, bucket, keys)
+        code, data = Storage.batch(command, bucket, keys)
+        code == StatusOK ? data : false
+      end
+
+      def batch_stat(bucket, keys)
+        code, data = Storage.batch_stat(bucket, keys)
+        code == StatusOK ? data : false
+      end
+
+      def batch_get(bucket, keys)
+        code, data = Storage.batch_get(bucket, keys)
+        code == StatusOK ? data : false
+      end
+
+      def batch_copy(*args)
+        code, data = Storage.batch_copy(args)
+        code == StatusOK
+      end
+
+      def batch_move(*args)
+        code, data = Storage.batch_move(args)
+        code == StatusOK
+      end
+
+      def batch_download(bucket, keys)
+        code, data = Storage.batch_get(bucket, keys)
+        return false unless code == StatusOK
+        links = []
+        data.each { |e| links << e["data"]["url"] }
+        links
+      end
+
+      def batch_delete(bucket, keys)
+        code, data = Storage.batch_delete(bucket, keys)
+        code == StatusOK ? data : false
+      end
+
+      def drop(bucket)
+        code, data = Storage.drop(bucket)
+        code == StatusOK
+      end
+
+      def image_info(url)
+        code, data = Fop::Image.info(url)
+        code == StatusOK ? data : false
+      end
+
+      def image_exif(url)
+        code, data = Fop::Image.exif(url)
+        code == StatusOK ? data : false
+      end
+
+      def image_mogrify_preview_url(source_image_url, options)
+        Fop::Image.mogrify_preview_url(source_image_url, options)
+      end
+
+      def image_mogrify_save_as(bucket, key, source_image_url, options)
+        code, data = Storage.image_mogrify_save_as(bucket, key, source_image_url, options)
+        code == StatusOK ? data : false
+      end
+
+      def generate_upload_token(opts = {})
+        token_obj = UploadToken.new(opts)
+        token_obj.access_key = Config.settings[:access_key]
+        token_obj.secret_key = Config.settings[:secret_key]
+        #token_obj.scope = opts[:scope]
+        #token_obj.expires_in = opts[:expires_in]
+        #token_obj.callback_url = opts[:callback_url]
+        #token_obj.callback_body_type = opts[:callback_body_type]
+        #token_obj.customer = opts[:customer]
+        #token_obj.escape = opts[:escape]
+        #token_obj.async_options = opts[:async_options]
+        #token_obj.return_body = opts[:return_body]
+        token_obj.generate_token
+      end
+
+      def generate_download_token(opts = {})
+        token_obj = DownloadToken.new(opts)
+        token_obj.access_key = Config.settings[:access_key]
+        token_obj.secret_key = Config.settings[:secret_key]
+        #token_obj.expires_in = opts[:expires_in]
+        #token_obj.pattern = opts[:pattern]
+        token_obj.generate_token
+      end
+
+    end
+
+end # module Qiniu

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,234 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+require 'hmac-sha1'
+require 'uri'
+
+require 'qiniu/exceptions'
+
+module Qiniu
+    module Auth
+      DEFAULT_AUTH_SECONDS = 3600
+
+      class << self
+        def calculate_deadline(expires_in, deadline = nil)
+          ### 授权期计算
+          if expires_in.is_a?(Integer) && expires_in > 0 then
+            # 指定相对时间，单位：秒
+            return Time.now.to_i + expires_in
+          elsif deadline.is_a?(Integer) then
+            # 指定绝对时间，常用于调试和单元测试
+            return deadline
+          end
+
+          # 默认授权期1小时
+          return Time.now.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_body          => "callbackBody"        ,
+          :persistent_ops         => "persistentOps"       ,
+          :persistent_notify_url  => "persistentNotifyUrl" ,
+          :persistent_pipeline    => "persistentPipeline"  ,
+
+          # 数值类型参数
+          :deadline               => "deadline"            ,
+          :insert_only            => "insertOnly"          ,
+          :fsize_limit            => "fsizeLimit"          ,
+          :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
+
+        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