qiniu 6.0.1

data/lib/qiniu/storage.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+require 'qiniu/upload'
+require 'qiniu/resumable_upload'
+require 'qiniu/management'

data/lib/qiniu/tokens/access_token.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'hmac-sha1'
+require 'qiniu/config'
+require 'qiniu/utils'
+
+module Qiniu
+      class AccessToken
+
+        include Utils
+
+        attr_accessor :access_key, :secret_key
+
+        def generate_encoded_digest(signature)
+          hmac = HMAC::SHA1.new(@secret_key)
+          hmac.update(signature)
+          urlsafe_base64_encode(hmac.digest)
+        end
+
+      end # AccessToken
+end # module Qiniu

data/lib/qiniu/tokens/download_token.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/utils'
+
+module Qiniu
+      class DownloadToken < AccessToken
+
+        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" => Time.now.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 = Utils.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,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/utils'
+
+module Qiniu
+      class UploadToken < AccessToken
+
+        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]
+          @async_options = opts[:async_options]
+          @return_body = opts[:return_body]
+          @return_url = opts[:return_url]
+        end
+
+        def generate_signature
+          params = {:scope => @scope, :deadline => Time.now.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[:asyncOps] = @async_options if !@async_options.nil? && !@async_options.empty?
+          params[:returnBody] = @return_body if !@return_body.nil? && !@return_body.empty?
+          params[:returnUrl] = @return_url if !@return_url.nil? && !@return_url.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,114 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module Storage
+    class << self
+      include Utils
+
+      def put_file(local_file,
+                   bucket,
+                   key = nil,
+                   mime_type = nil,
+                   custom_meta = nil,
+                   enable_crc32_check = false)
+        action_params = _generate_action_params(
+          local_file,
+          bucket,
+          key,
+          mime_type,
+          custom_meta,
+          enable_crc32_check
+        )
+
+        url = Config.settings[:io_host] + action_params
+        options = {:content_type => 'application/octet-stream'}
+
+        Auth.request url, ::IO.read(local_file), options
+      end # put_file
+
+      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 = Utils.generate_query_string(callback_params)
+        url = Config.settings[:up_host] + '/upload'
+
+        Utils.upload_multipart_data(url, local_file, action_params, callback_query_string, uptoken)
+      end # upload_with_token
+
+      def upload_with_token_2(uptoken,
+                              local_file,
+                              key = nil,
+                              x_vars = nil)
+        ### 构造URL
+        url = Config.settings[:up_host]
+        url[/\/*$/] = ''
+        url += '/'
+
+        ### 构造HTTP Body
+        post_data = {
+          :file      => File.new(local_file, 'rb'),
+          :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
+
+        ### 发送请求
+        Utils.http_request url, post_data
+      end # upload_with_token_2
+
+      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,151 @@
+# -*- 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 is_response_ok?(status_code)
+          status_code/100 == 2
+      end
+
+      def response_error(status_code, errmsg)
+          [status_code, {"error" => errmsg}]
+      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 is_response_ok?(code)
+          raise RequestFailed.new("Request Failed", response)
+        else
+          data = {}
+          body = response.respond_to?(:body) ? response.body : {}
+          data = safe_json_parse(body) unless body.empty?
+        end
+        [code, data]
+      end
+
+      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 : ""
+            data = safe_json_parse(body) unless body.empty?
+          end
+          [code, data]
+        end
+      end
+
+      def upload_multipart_data(url, filepath, action_string, callback_query_string = '', uptoken = nil)
+          post_data = {
+            :params => callback_query_string,
+            :action => action_string,
+            :file => File.new(filepath, 'rb'),
+            :multipart => true
+          }
+          post_data[:auth] = uptoken unless uptoken.nil?
+          http_request url, post_data
+      end
+
+      def generate_query_string(params)
+        return params if params.is_a?(String)
+        total_param = params.map { |key, value| %Q(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub('+', '%20')}) }
+        total_param.join("&")
+      end
+
+      def crc32checksum(filepath)
+        File.open(filepath, "rb") { |f| Zlib.crc32 f.read }
+      end
+
+      def generate_qbox_signature(url, params, mime = nil)
+        access_key = Config.settings[:access_key]
+        secret_key = Config.settings[:secret_key]
+        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 = generate_query_string(params)
+            signature += params_string
+        end
+        if mime.is_a?(String) && mime == "application/x-www-form-urlencoded" && params.is_a?(String)
+            signature += params
+        end
+        hmac = HMAC::SHA1.new(secret_key)
+        hmac.update(signature)
+        encoded_digest = urlsafe_base64_encode(hmac.digest)
+        %Q(#{access_key}:#{encoded_digest})
+      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 = 0
+      PATCH = 1
+      # 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/qiniu.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/qiniu/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["why404"]
+  gem.email         = ["why404@gmail.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
+
+  # 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