qiniu_jxb_fix 6.4.2

data/lib/qiniu/tokens/download_token.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/utils'
+require 'qiniu/helper'
+
+### DownloadToken 类已经过时，请改用 Qiniu::Auth.authorize_download_url 方法 ###
+### 或 Qiniu::Auth.authorize_download_url_2 方法                             ###
+
+module Qiniu
+      class DownloadToken < AccessToken
+        include Helper
+
+        include Utils
+
+        attr_accessor :pattern, :expires_in
+
+        def initialize(opts = {})
+          @pattern = opts[:pattern]
+          @expires_in = opts[:expires_in] || 3600
+        end
+
+        def generate_signature
+          params = {"S" => @pattern, "E" => get_expire_time.to_i + @expires_in}
+          Utils.urlsafe_base64_encode(params.to_json)
+        end
+
+        def generate_token
+          signature = generate_signature
+          encoded_digest = generate_encoded_digest(signature)
+          %Q(#{@access_key}:#{encoded_digest}:#{signature})
+        end
+
+      end # moidule DownloadToken
+end # module Qiniu

data/lib/qiniu/tokens/qbox_token.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'cgi'
+require 'json'
+require 'qiniu/tokens/access_token'
+
+module Qiniu
+      class QboxToken < AccessToken
+
+        include Utils
+
+        attr_accessor :url, :params
+
+        def initialize(opts = {})
+          @url = opts[:url]
+          @params = opts[:params]
+        end
+
+        def generate_signature
+          uri = URI.parse(@url)
+          signature = uri.path
+          query_string = uri.query
+          signature += '?' + query_string if !query_string.nil? && !query_string.empty?
+          signature += "\n"
+          if @params.is_a?(Hash)
+              params_string = HTTP.generate_query_string(@params)
+              signature += params_string
+          end
+          signature
+        end
+
+        def generate_token
+          encoded_digest = generate_encoded_digest(generate_signature)
+          %Q(#{@access_key}:#{encoded_digest})
+        end
+
+      end # module QboxToken
+end # module Qiniu

data/lib/qiniu/tokens/upload_token.rb

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/utils'
+require 'qiniu/helper'
+
+### UploadToken 类已经过时，请改用 Qiniu::Auth.generate_uptoken 方法 ###
+
+module Qiniu
+      class UploadToken < AccessToken
+
+        include Helper
+        include Utils
+
+        attr_accessor :scope, :expires_in, :callback_url, :callback_body, :callback_body_type, :customer, :escape, :async_options, :return_body, :return_url
+
+        def initialize(opts = {})
+          @scope = opts[:scope]
+          @expires_in = opts[:expires_in] || 3600
+          @callback_url = opts[:callback_url]
+          @callback_body = opts[:callback_body]
+          @callback_body_type = opts[:callback_body_type]
+          @customer = opts[:customer]
+          @escape = opts[:escape]
+          @persistent_ops = opts[:persistent_ops]
+          @persistent_notify_url = opts[:persistent_notify_url]
+          @persistent_pipeline = opts[:persistent_pipeline]
+          @return_body = opts[:return_body]
+          @return_url = opts[:return_url]
+        end
+
+        def generate_signature
+          params = {:scope => @scope, :deadline => get_expire_time.to_i + @expires_in}
+          params[:callbackUrl] = @callback_url if !@callback_url.nil? && !@callback_url.empty?
+          params[:callbackBody] = @callback_body if !@callback_body.nil? && !@callback_body.empty?
+          params[:callbackBodyType] = @callback_body_type if !@callback_body_type.nil? && !@callback_body_type.empty?
+          params[:customer] = @customer if !@customer.nil? && !@customer.empty?
+          params[:escape] = 1 if @escape == 1 || @escape == true
+          params[:returnBody] = @return_body if !@return_body.nil? && !@return_body.empty?
+          params[:returnUrl] = @return_url if !@return_url.nil? && !@return_url.empty?
+
+          params[:persistentOps] = @persistent_ops if !@persistent_ops.nil? && !@persistent_ops.empty?
+          params[:persistentNotifyUrl] = @persistent_notify_url if !@persistent_notify_url.nil? && !@persistent_notify_url.empty?
+          params[:persistentPipeline] = @persistent_pipeline if !@persistent_pipeline.nil? && !@persistent_pipeline.empty?
+
+          Utils.urlsafe_base64_encode(params.to_json)
+        end
+
+        def generate_token
+          signature = generate_signature
+          encoded_digest = generate_encoded_digest(signature)
+          %Q(#{@access_key}:#{encoded_digest}:#{signature})
+        end
+
+      end # module UploadToken
+end # module Qiniu

data/lib/qiniu/upload.rb

@@ -0,0 +1,134 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+module Qiniu
+  module Storage
+    class << self
+      include Utils
+
+      def upload_with_token(uptoken,
+                            local_file,
+                            bucket,
+                            key = nil,
+                            mime_type = nil,
+                            custom_meta = nil,
+                            callback_params = nil,
+                            enable_crc32_check = false,
+                            rotate = nil)
+        action_params = _generate_action_params(
+          local_file,
+          bucket,
+          key,
+          mime_type,
+          custom_meta,
+          enable_crc32_check,
+          rotate
+        )
+
+        if callback_params.nil?
+          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type}
+        end
+        callback_query_string = HTTP.generate_query_string(callback_params)
+
+        url = Config.settings[:up_host] + '/upload'
+        post_data = {
+          :params     => callback_query_string,
+          :action     => action_params,
+          :file       => File.new(local_file, 'rb'),
+          :multipart  => true
+        }
+        if !uptoken.nil? then
+          post_data[:auth] = uptoken unless uptoken.nil?
+        end
+
+        return HTTP.api_post(url, post_data)
+      end # upload_with_token
+
+      def upload_with_token_2(uptoken,
+                              local_file,
+                              key = nil,
+                              x_vars = nil,
+                              opts = {})
+        ### 构造URL
+        url = Config.settings[:up_host]
+        url[/\/*$/] = ''
+        url += '/'
+
+        ### 构造HTTP Body
+        file = File.new(local_file, 'rb')
+        if not opts[:content_type].nil?
+          file.define_singleton_method("content_type") do
+            opts[:content_type]
+          end
+        end
+
+        post_data = {
+          :file      => file,
+          :multipart => true,
+        }
+        if not uptoken.nil?
+          post_data[:token] = uptoken
+        end
+        if not key.nil?
+          post_data[:key] = key
+        end
+        if x_vars.is_a?(Hash)
+          post_data.merge!(x_vars)
+        end
+
+        ### 发送请求
+        HTTP.api_post(url, post_data)
+      end # upload_with_token_2
+
+      ### 授权举例
+      # put_policy.bucket | put_policy.key | key     | 语义 | 授权
+      # :---------------- | :------------- | :------ | :--- | :---
+      # trivial_bucket    | <nil>          | <nil>   | 新增 | 允许，最终key为1)使用put_policy.save_key生成的值或2)资源内容的Hash值
+      # trivial_bucket    | <nil>          | foo.txt | 新增 | 允许
+      # trivial_bucket    | <nil>          | bar.jpg | 新增 | 允许
+      # trivial_bucket    | foo.txt        | <nil>   | 覆盖 | 允许，由SDK将put_policy.key赋值给key实现
+      # trivial_bucket    | foo.txt        | foo.txt | 覆盖 | 允许
+      # trivial_bucket    | foo.txt        | bar.jpg | 覆盖 | 禁止，put_policy.key与key不一致
+      def upload_with_put_policy(put_policy,
+                                 local_file,
+                                 key = nil,
+                                 x_vars = nil,
+                                 opts = {})
+        uptoken = Auth.generate_uptoken(put_policy)
+        if key.nil? then
+          key = put_policy.key
+        end
+
+        return upload_with_token_2(uptoken, local_file, key, x_vars, opts)
+      end # upload_with_put_policy
+
+      private
+      def _generate_action_params(local_file,
+                                  bucket,
+                                  key = nil,
+                                  mime_type = nil,
+                                  custom_meta = nil,
+                                  enable_crc32_check = false,
+                                  rotate = nil)
+        raise NoSuchFileError, local_file unless File.exist?(local_file)
+
+        if key.nil?
+          key = Digest::SHA1.hexdigest(local_file + Time.now.to_s)
+        end
+
+        entry_uri = bucket + ':' + key
+        if mime_type.nil? || mime_type.empty?
+          mime = MIME::Types.type_for local_file
+          mime_type = mime.empty? ? 'application/octet-stream' : mime[0].content_type
+        end
+
+        action_params = '/rs-put/' + Utils.urlsafe_base64_encode(entry_uri) + '/mimeType/' + Utils.urlsafe_base64_encode(mime_type)
+        action_params += '/meta/' + Utils.urlsafe_base64_encode(custom_meta) unless custom_meta.nil?
+        action_params += '/crc32/' + Utils.crc32checksum(local_file).to_s if enable_crc32_check
+        action_params += '/rotate/' + rotate if !rotate.nil? && rotate.to_i >= 0
+        action_params
+      end # _generate_action_params
+
+    end # class << self
+  end # module Storage
+end # module Qiniu

data/lib/qiniu/utils.rb

@@ -0,0 +1,109 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'cgi'
+require 'json'
+require 'zlib'
+require 'base64'
+require 'rest_client'
+require 'hmac-sha1'
+require 'qiniu/exceptions'
+
+module Qiniu
+    module Utils extend self
+
+      def urlsafe_base64_encode content
+        Base64.encode64(content).strip.gsub('+', '-').gsub('/','_').gsub(/\r?\n/, '')
+      end
+
+      def urlsafe_base64_decode encoded_content
+        Base64.decode64 encoded_content.gsub('_','/').gsub('-', '+')
+      end
+
+      def encode_entry_uri(bucket, key)
+        entry_uri = bucket + ':' + key
+        urlsafe_base64_encode(entry_uri)
+      end
+
+      def safe_json_parse(data)
+        JSON.parse(data)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def debug(msg)
+          if Config.settings[:enable_debug]
+              Log.logger.debug(msg)
+          end
+      end
+
+      ### 已过时，仅作为兼容接口保留
+      def send_request_with url, data = nil, options = {}
+        options[:method] = Config.settings[:method] unless options[:method]
+        options[:content_type] = Config.settings[:content_type] unless options[:content_type]
+        header_options = {
+          :accept => :json,
+          :user_agent => Config.settings[:user_agent]
+        }
+        auth_token = nil
+        if !options[:qbox_signature_token].nil? && !options[:qbox_signature_token].empty?
+          auth_token = 'QBox ' + options[:qbox_signature_token]
+        elsif !options[:upload_signature_token].nil? && !options[:upload_signature_token].empty?
+          auth_token = 'UpToken ' + options[:upload_signature_token]
+        elsif options[:access_token]
+          auth_token = 'Bearer ' + options[:access_token]
+        end
+        header_options.merge!('Authorization' => auth_token) unless auth_token.nil?
+        case options[:method]
+        when :get
+          response = RestClient.get(url, header_options)
+        when :post
+          header_options.merge!(:content_type => options[:content_type])
+          response = RestClient.post(url, data, header_options)
+        end
+        code = response.respond_to?(:code) ? response.code.to_i : 0
+        unless HTTP.is_response_ok?(code)
+          raise RequestFailed.new("Request Failed", response)
+        else
+          data = {}
+          body = response.respond_to?(:body) ? response.body : {}
+          raw_headers = response.respond_to?(:raw_headers) ? response.raw_headers : {}
+          data = safe_json_parse(body) unless body.empty?
+        end
+        [code, data, raw_headers]
+      end # send_request_with
+
+      ### 已过时，仅作为兼容接口保留
+      def http_request url, data = nil, options = {}
+        retry_times = 0
+        begin
+          retry_times += 1
+          send_request_with url, data, options
+        rescue Errno::ECONNRESET => err
+          if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
+            retry
+          else
+            Log.logger.error err
+          end
+        rescue => e
+          Log.logger.warn "#{e.message} => Utils.http_request('#{url}')"
+          code = 0
+          data = {}
+          body = {}
+          if e.respond_to? :response
+            res = e.response
+            code = res.code.to_i if res.respond_to? :code
+            body = res.respond_to?(:body) ? res.body : ""
+            raw_headers = res.respond_to?(:raw_headers) ? res.raw_headers : {}
+            data = safe_json_parse(body) unless body.empty?
+          end
+          [code, data, raw_headers]
+        end
+      end
+
+      def crc32checksum(filepath)
+        File.open(filepath, "rb") { |f| Zlib.crc32 f.read }
+      end
+
+    end # module Utils
+end # module Qiniu

data/lib/qiniu/version.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+    module Version
+      MAJOR = 6
+      MINOR = 4
+      PATCH = 2
+      # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
+      #
+      # Example
+      #
+      #   Version.to_s # '1.0.2'
+      def self.to_s
+        [MAJOR, MINOR, PATCH].join('.')
+      end
+    end # Version
+end # module Qiniu

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/qiniu.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/qiniu/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["why404","BluntBlade"]
+  gem.email         = ["sdk@qiniu.com"]
+  gem.description   = %q{Qiniu Resource (Cloud) Storage SDK for Ruby. See: http://developer.qiniu.com/docs/v6/sdk/ruby-sdk.html}
+  gem.summary       = %q{Qiniu Resource (Cloud) Storage SDK for Ruby}
+  gem.homepage      = "https://github.com/qiniu/ruby-sdk"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "qiniu_jxb_fix"
+  gem.require_paths = ["lib"]
+  gem.version       = Qiniu::Version.to_s
+  gem.license       = "MIT"
+
+  # specify any dependencies here; for example:
+  gem.add_development_dependency "rake", ">= 0.9"
+  gem.add_development_dependency "rspec", ">= 2.11"
+  gem.add_development_dependency "fakeweb", "~> 1.3"
+  gem.add_runtime_dependency "json", "~> 1.7"
+  gem.add_runtime_dependency "rest-client", "~> 1.6"
+  gem.add_runtime_dependency "mime-types", "~> 1.19"
+  gem.add_runtime_dependency "ruby-hmac", "~> 0.4"
+  gem.add_runtime_dependency "jruby-openssl", "~> 0.7" if RUBY_PLATFORM == "java"
+end

data/rails3/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails3/qiniu.gemspec
+gemspec :name => 'qiniu'

data/rails3/qiniu.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../../lib/qiniu/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["why404","BluntBlade"]
+  gem.email         = ["sdk@qiniu.com"]
+  gem.description   = %q{Qiniu Resource (Cloud) Storage SDK for Ruby. See: http://developer.qiniu.com/docs/v6/sdk/ruby-sdk.html}
+  gem.summary       = %q{Qiniu Resource (Cloud) Storage SDK for Ruby}
+  gem.homepage      = "https://github.com/qiniu/ruby-sdk"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "qiniu"
+  gem.require_paths = ["lib"]
+  gem.version       = Qiniu::Version.to_s
+  gem.license       = "MIT"
+
+  # specify any dependencies here; for example:
+  gem.add_development_dependency "rake", ">= 0.9"
+  gem.add_development_dependency "rspec", ">= 2.11"
+  gem.add_development_dependency "fakeweb", "~> 1.3"
+  gem.add_runtime_dependency "json", "~> 1.8"
+  gem.add_runtime_dependency "rest-client", "~> 1.7.3"
+  gem.add_runtime_dependency "mime-types", "~> 1.19"
+  gem.add_runtime_dependency "ruby-hmac", "~> 0.4"
+  gem.add_runtime_dependency "jruby-openssl", "~> 0.7" if RUBY_PLATFORM == "java"
+end