update version for refresh gems

去掉publish/unpublish接口的封装函数。

.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
 rvm:
+  - 1.8.7
+  - 1.9.2
   - 1.9.3
   - 2.0.0
-  - 2.1.1
+  - jruby-18mode
   - jruby-19mode
+  - jruby-head
+  - ree
 before_script:
   - export QINIU_ACCESS_KEY=LGRqJsjX7LAvtdtX6hhyxs861lS57HwnOQmJsOuX
   - export QINIU_SECRET_KEY=g_OxhuN5iJ1O7BoA6YdXyF6zSszk34UZFKDfdIIW

CHANGELOG.md

@@ -1,30 +1,16 @@
 ## CHANGE LOG
 
-### v6.2.1
+### v3.4.9
 
-- 去除已废弃的publish/unpublish接口。 [https://github.com/qiniu/ruby-sdk/pull/90](https://github.com/qiniu/ruby-sdk/pull/90) (#8143)
+- 去掉publish和unpublish接口的封装函数。 [https://github.com/qiniu/ruby-sdk/pull/89](https://github.com/qiniu/ruby-sdk/pull/89) (#8143)
 
-### v6.2.0
+### v3.4.8
 
-- 重写与授权相关的函数并归入Qiniu::Auth空间，原授权凭证生成类维持不变。
+- 修复断点续上传功能中一直重试上传出错片的Bug。[https://github.com/qiniu/ruby-sdk/pull/87](https://github.com/qiniu/ruby-sdk/pull/87) (#7205)
 
-- 添加Qiniu::Storage::PutPolicy类和Qiniu::Storage#upload_with_put_policy方法，并推荐使用两者组合实现单文件上传。
+### v3.4.7
 
-### v6.1.0
-
-- Qiniu::Storage所有上传接口返回第三个值raw_headers，类型为Hash，包含已解析的HTTP响应报文中的所有Header信息。
-
-该返回值主要用于调试。当遇到难以理解或解释的错误时，请将其中的X-Log和X-Reqid两项信息[通过邮件反馈](mailto:support@qiniu.com?subject=Ruby-SDK-Bug-Report)给我们。
-
-- 更新Qiniu::Storage所有上传接口的测试用例，打印HTTP响应Header信息。
-
-- 删除过时的Qiniu::Storage#put_file方法和相关测试用例。
-
-该方法调用的API已过时并逐步废弃，建议用户尽快迁移到Qiniu::Storage#upload_with_token_2方法上。
-
-### v6.0.1
-
-- 重新划分命名空间，存储相关归入Qiniu::Storage，数据处理相关归入Qiniu::Fop，杂项相关归入Qiniu::Misc。
+- 停止追加新功能，仅进行Bug修正维护。  
 
 ### v3.4.6
 

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qiniu (6.2.1)
+    qiniu-rs (3.4.9)
       json (~> 1.7)
       mime-types (~> 1.19)
       rest-client (~> 1.6)
@@ -32,6 +32,6 @@ PLATFORMS
 
 DEPENDENCIES
   fakeweb (~> 1.3)
-  qiniu!
+  qiniu-rs!
   rake (>= 0.9)
   rspec (>= 2.11)

README.md

@@ -1,21 +1,19 @@
 # Qiniu Resource (Cloud) Storage SDK for Ruby
 
-## 关于
+# 版本说明
 
-此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, 2.0.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](http://developer.qiniu.com/docs/v6/index.html) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
+此版本不再进行技术升级，仅做Bug修正维护。  
+请移步 [https://github.com/qiniu/ruby-sdk](https://github.com/qiniu/ruby-sdk) 查看最新版本。  
 
-## 状态
+# 关于
 
-[![Build Status](https://api.travis-ci.org/qiniu/ruby-sdk.png?branch=master)](https://travis-ci.org/qiniu/ruby-sdk)
-[![Gem Version](https://badge.fury.io/rb/qiniu.png)](http://badge.fury.io/rb/qiniu)
-[![Dependency Status](https://gemnasium.com/qiniu/ruby-sdk.png)](https://gemnasium.com/qiniu/ruby-sdk)
-[![Code Climate](https://codeclimate.com/github/qiniu/ruby-sdk.png)](https://codeclimate.com/github/qiniu/ruby-sdk)
+此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](http://developer.qiniu.com/docs/v6/index.html) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
 
 ## 安装
 
 在您 Ruby 应用程序的 `Gemfile` 文件中，添加如下一行代码：
 
-    gem 'qiniu', '~> 6.1.0'
+    gem 'qiniu-rs'
 
 然后，在应用程序所在的目录下，可以运行 `bundle` 安装依赖包：
 
@@ -23,7 +21,7 @@
 
 或者，可以使用 Ruby 的包管理器 `gem` 进行安装：
 
-    $ gem install qiniu
+    $ gem install qiniu-rs
 
 ## 使用
 
@@ -39,7 +37,7 @@
 
 ## 许可证
 
-Copyright (c) 2012-2014 qiniu.com
+Copyright (c) 2012-2013 qiniutek.com
 
 基于 MIT 协议发布:
 

lib/qiniu-rs.rb

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

lib/qiniu/adt.rb

@@ -1,46 +0,0 @@
-# -*- 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

lib/qiniu/auth.rb

@@ -1,222 +0,0 @@
-# -*- 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" ,
-          :transform              => "transform"           ,
-
-          # 数值类型参数
-          :deadline               => "deadline"            ,
-          :insert_only            => "insertOnly"          ,
-          :fsize_limit            => "fsizeLimit"          ,
-          :detect_mime            => "detectMime"          ,
-          :mime_limit             => "mimeLimit"           ,
-          :fop_timeout            => "fopTimeout"
-        } # 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]
-
-          ### 授权期计算
-          e = Auth.calculate_deadline(args[:expires_in], args[:deadline])
-
-          ### URL变换：追加授权期参数
-          if url.index('?').is_a?(Fixnum) then
-            # 已有参数
-            download_url = "#{url}&e=#{e}"
-          else
-            # 尚无参数
-            download_url = "#{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

lib/qiniu/fop.rb

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

lib/qiniu/http.rb

@@ -1,137 +0,0 @@
-# -*- 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

lib/qiniu/misc.rb

@@ -1,33 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Qiniu
-    module Misc
-      class << self
-        def set_protected(bucket, protected_mode)
-          url = Config.settings[:pub_host] + %Q(/accessMode/#{bucket}/mode/#{protected_mode})
-          return HTTP.management_post(url)
-        end # set_protected
-
-        def set_separator(bucket, separator)
-          encoded_separator = Utils.urlsafe_base64_encode(separator)
-          url = Config.settings[:pub_host] + %Q(/separator/#{bucket}/sep/#{encoded_separator})
-          return HTTP.management_post(url)
-        end # set_separator
-
-        def set_style(bucket, name, style)
-          encoded_name = Utils.urlsafe_base64_encode(name)
-          encoded_style = Utils.urlsafe_base64_encode(style)
-          url = Config.settings[:pub_host] + %Q(/style/#{bucket}/name/#{encoded_name}/style/#{encoded_style})
-          return HTTP.management_post(url)
-        end # set_style
-
-        def unset_style(bucket, name)
-          encoded_name = Utils.urlsafe_base64_encode(name)
-          url = Config.settings[:pub_host] + %Q(/unstyle/#{bucket}/name/#{encoded_name})
-          return HTTP.management_post(url)
-        end # unset_style
-      end # class << self
-
-    end # module Misc
-end # module Qiniu
-

lib/qiniu/pfop.rb

@@ -1,123 +0,0 @@
-# -*- encoding: utf-8 -*-
-# vim: sw=2 ts=2
-
-require 'qiniu/adt'
-require 'qiniu/http'
-
-module Qiniu
-  module Fop
-    module Persistance
-
-      class PfopPolicy
-        include ADT::Policy
-
-        private
-        def initialize(bucket,
-                       key,
-                       fops,
-                       notify_url)
-          @bucket     = bucket
-          @key        = key
-          @notify_url = notify_url
-
-          self.fops!(fops)
-        end # initialize
-
-        public
-        PARAMS = {
-          # 字符串类型参数
-          :bucket     =>  "bucket",
-          :key        =>  "key",
-          :fops       =>  "fops",
-          :notify_url =>  "notifyURL",
-
-          # 数值类型参数
-          :force      =>  "force"
-        } # PARAMS
-
-        PARAMS.each_pair do |key, fld|
-          attr_accessor key
-        end
-
-        def params
-          return PARAMS
-        end # params
-
-        def fops! (fops)
-          if fops.is_a?(Hash) then
-            fops = fops.values
-          end
-
-          if fops.is_a?(Array) then
-            new_fops = []
-            fops.each do |v|
-              if v.is_a?(ApiSpecification) then
-                new_fops.push(v.to_s)
-              end
-            end
-
-            @fops = new_fops.join(";")
-          else
-            @fops = fops.to_s
-          end
-        end # fops!
-
-        def force!
-          @force = 1
-        end # force!
-
-        alias :to_s :to_json
-      end # class PfopPolicy
-
-      class << self
-
-        API_HOST = 'http://api.qiniu.com'
-
-        PFOP_URL = API_HOST + '/pfop/'
-
-        def pfop (args)
-          ### 生成fop指令串
-          if args.is_a?(PfopPolicy) then
-            # PfopPolicy的各个字段按固定顺序组织
-            body = args.to_query_string()
-          elsif args.is_a?(Hash) then
-            # 无法保证固定字段顺序
-            body = HTTP.generate_query_string(args)
-          else
-            # 由调用者保证固定字段顺序
-            body = args.to_s
-          end
-
-          ### 发送请求
-          return HTTP.management_post(PFOP_URL, body)
-        end # pfop
-
-        PREFOP_URL = API_HOST + '/status/get/prefop?id='
-
-        def prefop (persistent_id)
-          ### 抽取persistentId
-          if persistent_id.is_a?(Hash) then
-            pid = persistent_id['persistentId']
-          else
-            pid = persistent_id.to_s
-          end
-
-          ### 发送请求
-          url = PREFOP_URL + pid
-          return HTTP.api_get(url)
-        end # prefop
-
-        def generate_p1_url (url, fop)
-          # 如果fop是ApiSpecification，则各字段按固定顺序组织，保证一致性
-          # 否则由调用者保证固定字段顺序
-          fop = CGI.escape(fop.to_s).gsub('+', '%20')
-
-          ### 生成url
-          return url + '?p/1/' + fop
-        end # generate_pl_url
-
-      end # class << self
-
-    end # module Persistance
-  end # module Fop
-end # module Qiniu

lib/qiniu/rs.rb

@@ -1,20 +1,24 @@
 # -*- 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'
+  module RS
+    autoload :Version, 'qiniu/rs/version'
+    autoload :Config, 'qiniu/rs/config'
+    autoload :Log, 'qiniu/rs/log'
+    autoload :Exception, 'qiniu/rs/exceptions'
+    autoload :Utils, 'qiniu/rs/utils'
+    autoload :Auth, 'qiniu/rs/auth'
+    autoload :IO, 'qiniu/rs/io'
+    autoload :UP, 'qiniu/rs/up'
+    autoload :RS, 'qiniu/rs/rs'
+    autoload :EU, 'qiniu/rs/eu'
+    autoload :Pub, 'qiniu/rs/pub'
+    autoload :Image, 'qiniu/rs/image'
+    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/rs/abstract'
 
     class << self
 
@@ -24,33 +28,77 @@ module Qiniu
         Config.initialize_connect opts
       end
 
+      def login!(user, pwd)
+        code, data = Auth.exchange_by_password!(user, pwd)
+        code == StatusOK
+      end
+
       def mkbucket(bucket_name)
-        code, data = Storage.mkbucket(bucket_name)
+        code, data = RS.mkbucket(bucket_name)
         code == StatusOK
       end
 
       def buckets
-        code, data = Storage.buckets
+        code, data = RS.buckets
         code == StatusOK ? data : false
       end
 
       def set_protected(bucket, protected_mode)
-        code, data = Misc.set_protected(bucket, protected_mode)
+        code, data = Pub.set_protected(bucket, protected_mode)
         code == StatusOK
       end
 
       def set_separator(bucket, separator)
-        code, data = Misc.set_separator(bucket, separator)
+        code, data = Pub.set_separator(bucket, separator)
         code == StatusOK
       end
 
       def set_style(bucket, name, style)
-        code, data = Misc.set_style(bucket, name, style)
+        code, data = Pub.set_style(bucket, name, style)
         code == StatusOK
       end
 
       def unset_style(bucket, name)
-        code, data = Misc.unset_style(bucket, name)
+        code, data = Pub.unset_style(bucket, name)
+        code == StatusOK
+      end
+
+=begin
+      def set_watermark(customer_id, options = {})
+        code, data = EU.set_watermark(customer_id, options)
+        code == StatusOK
+      end
+
+      def get_watermark(customer_id = nil)
+        code, data = EU.get_watermark(customer_id)
+        code == StatusOK ? data : false
+      end
+=end
+
+      def put_auth(expires_in = nil, callback_url = nil)
+        code, data = IO.put_auth(expires_in, callback_url)
+        code == StatusOK ? data["url"] : false
+      end
+
+      def upload opts = {}
+        code, data = IO.upload_file(opts[:url],
+                                    opts[:file],
+                                    opts[:bucket],
+                                    opts[:key],
+                                    opts[:mime_type],
+                                    opts[:note],
+                                    opts[:callback_params],
+                                    opts[:enable_crc32_check])
+        code == StatusOK
+      end
+
+      def put_file opts = {}
+        code, data = IO.put_file(opts[:file],
+                                 opts[:bucket],
+                                 opts[:key],
+                                 opts[:mime_type],
+                                 opts[:note],
+                                 opts[:enable_crc32_check])
         code == StatusOK
       end
 
@@ -64,7 +112,7 @@ module Qiniu
         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],
+          code, data = UP.upload_with_token(opts[:uptoken],
                                             opts[:file],
                                             opts[:bucket],
                                             opts[:key],
@@ -74,7 +122,7 @@ module Qiniu
                                             opts[:callback_params],
                                             opts[:rotate])
         else
-          code, data, raw_headers = Storage.upload_with_token(opts[:uptoken],
+          code, data = IO.upload_with_token(opts[:uptoken],
                                             opts[:file],
                                             opts[:bucket],
                                             opts[:key],
@@ -89,62 +137,62 @@ module Qiniu
       end
 
       def stat(bucket, key)
-        code, data = Storage.stat(bucket, key)
+        code, data = RS.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, data = RS.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, data = RS.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, data = RS.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, data = RS.move(source_bucket, source_key, target_bucket, target_key)
         code == StatusOK
       end
 
       def delete(bucket, key)
-        code, data = Storage.delete(bucket, key)
+        code, data = RS.delete(bucket, key)
         code == StatusOK
       end
 
       def batch(command, bucket, keys)
-        code, data = Storage.batch(command, bucket, keys)
+        code, data = RS.batch(command, bucket, keys)
         code == StatusOK ? data : false
       end
 
       def batch_stat(bucket, keys)
-        code, data = Storage.batch_stat(bucket, keys)
+        code, data = RS.batch_stat(bucket, keys)
         code == StatusOK ? data : false
       end
 
       def batch_get(bucket, keys)
-        code, data = Storage.batch_get(bucket, keys)
+        code, data = RS.batch_get(bucket, keys)
         code == StatusOK ? data : false
       end
 
       def batch_copy(*args)
-        code, data = Storage.batch_copy(args)
+        code, data = RS.batch_copy(*args)
         code == StatusOK
       end
 
       def batch_move(*args)
-        code, data = Storage.batch_move(args)
+        code, data = RS.batch_move(*args)
         code == StatusOK
       end
 
       def batch_download(bucket, keys)
-        code, data = Storage.batch_get(bucket, keys)
+        code, data = RS.batch_get(bucket, keys)
         return false unless code == StatusOK
         links = []
         data.each { |e| links << e["data"]["url"] }
@@ -152,31 +200,35 @@ module Qiniu
       end
 
       def batch_delete(bucket, keys)
-        code, data = Storage.batch_delete(bucket, keys)
+        code, data = RS.batch_delete(bucket, keys)
         code == StatusOK ? data : false
       end
 
       def drop(bucket)
-        code, data = Storage.drop(bucket)
+        code, data = RS.drop(bucket)
         code == StatusOK
       end
 
       def image_info(url)
-        code, data = Fop::Image.info(url)
+        code, data = Image.info(url)
         code == StatusOK ? data : false
       end
 
       def image_exif(url)
-        code, data = Fop::Image.exif(url)
+        code, data = Image.exif(url)
         code == StatusOK ? data : false
       end
 
+      def image_preview_url(url, spec)
+        Image.preivew_url(url, spec)
+      end
+
       def image_mogrify_preview_url(source_image_url, options)
-        Fop::Image.mogrify_preview_url(source_image_url, options)
+        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, data = RS.image_mogrify_save_as(bucket, key, source_image_url, options)
         code == StatusOK ? data : false
       end
 
@@ -206,4 +258,5 @@ module Qiniu
 
     end
 
-end # module Qiniu
+  end
+end

lib/qiniu/rs/abstract.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 module Qiniu
+  module RS
     module Abstract
       def self.included(base)
         base.extend(ClassMethods)
@@ -18,5 +19,6 @@ module Qiniu
           end
         end
       end
-    end # module Abstract
-end # module Qiniu
+    end
+  end
+end

lib/qiniu/rs/auth.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require 'qiniu/rs/exceptions'
+
+module Qiniu
+  module RS
+    module Auth
+      class << self
+        include Utils
+
+        def call_with_signature(url, data, retry_times = 0, options = {})
+          code, data = http_request url, data, options.merge({:qbox_signature_token => generate_qbox_signature(url, data, options[:mime])})
+          [code, data]
+        end
+
+        def request(url, data = nil, options = {})
+              code, data = Auth.call_with_signature(url, data, 0, options)
+          [code, data]
+        end
+
+      end
+    end
+  end
+end

lib/qiniu/rs/config.rb

@@ -11,6 +11,7 @@
 require 'tmpdir'
 
 module Qiniu
+  module RS
     module Config
       class << self
 
@@ -20,6 +21,7 @@ module Qiniu
           :content_type    => 'application/x-www-form-urlencoded',
           :auth_url        => "https://acc.qbox.me/oauth2/token",
           :rs_host         => "http://rs.qiniu.com",
+          :io_host         => "http://iovip.qbox.me",
           :up_host         => "http://up.qiniu.com",
           :pub_host        => "http://pu.qbox.me:10200",
           :eu_host         => "http://eu.qbox.me",
@@ -56,5 +58,6 @@ module Qiniu
         end
 
       end
-    end # module Config
-end # module Qiniu
+    end
+  end
+end

lib/qiniu/rs/eu.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module EU
+      class << self
+        include Utils
+
+        def set_watermark(customer_id, options = {})
+          Auth.request Config.settings[:eu_host] + '/wmset', options.merge({:customer => customer_id})
+        end
+
+        def get_watermark(customer_id = nil)
+          post_data = customer_id.nil? ? nil : {:customer => customer_id}
+          Auth.request Config.settings[:eu_host] + '/wmget', post_data
+        end
+
+      end
+    end
+  end
+end
+

lib/qiniu/rs/exceptions.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 module Qiniu
+  module RS
 
     class Exception < RuntimeError
     end
@@ -117,4 +118,5 @@ module Qiniu
       end
     end
 
-end # module Qiniu
+  end
+end

lib/qiniu/rs/image.rb

@@ -1,18 +1,22 @@
 # -*- encoding: utf-8 -*-
 
 module Qiniu
-  module Fop
+  module RS
     module Image
       class << self
         include Utils
 
         def info(url)
-          return HTTP.api_get(url + '?imageInfo')
-        end # info
+          Utils.http_request url + '/imageInfo', nil, {:method => :get}
+        end
 
         def exif(url)
-          return HTTP.api_get(url + '?exif')
-        end # exif
+          Utils.http_request url + '?exif', nil, {:method => :get}
+        end
+
+        def preivew_url(url, spec)
+          url + '/imagePreview/' + spec.to_s
+        end
 
         def mogrify_preview_url(source_image_url, options)
           source_image_url + '?' + generate_mogrify_params_string(options)
@@ -33,6 +37,6 @@ module Qiniu
         end
 
       end
-    end # module Image
-  end # module Fop
-end # module Qiniu
+    end
+  end
+end

lib/qiniu/rs/io.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'mime/types'
+require 'digest/sha1'
+require 'qiniu/rs/exceptions'
+
+module Qiniu
+  module RS
+    module IO
+      class << self
+        include Utils
+
+        def put_auth(expires_in = nil, callback_url = nil)
+          url = Config.settings[:io_host] + "/put-auth/"
+          url += "#{expires_in}" if !expires_in.nil? && expires_in > 0
+          if !callback_url.nil? && !callback_url.empty?
+            encoded_callback_url = Utils.urlsafe_base64_encode(callback_url)
+            url += "/callback/#{encoded_callback_url}"
+          end
+          Auth.request(url)
+        end
+
+        def upload_file(url, local_file, bucket, key = nil, mime_type = nil, custom_meta = nil, callback_params = nil, enable_crc32_check = false)
+          action_params = _generate_action_params(local_file, bucket, key, mime_type, custom_meta, enable_crc32_check)
+          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type} if callback_params.nil?
+          callback_query_string = Utils.generate_query_string(callback_params)
+          Utils.upload_multipart_data(url, local_file, action_params, callback_query_string)
+        end
+
+        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
+
+        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)
+          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type} if callback_params.nil?
+          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
+
+        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)
+          key = Digest::SHA1.hexdigest(local_file + Time.now.to_s) if key.nil?
+          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
+
+      end
+    end
+  end
+end

lib/qiniu/rs/log.rb

@@ -3,6 +3,7 @@
 require 'logger'
 
 module Qiniu
+  module RS
     module Log
       class << self
         attr_accessor :logger
@@ -11,5 +12,6 @@ module Qiniu
           @logger ||= Logger.new(STDERR)
         end
       end
-    end # module Log
-end # module Qiniu
+    end
+  end
+end

lib/qiniu/rs/pub.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module Pub
+      class << self
+        include Utils
+
+        def set_protected(bucket, protected_mode)
+          host = Config.settings[:pub_host]
+          Auth.request %Q(#{host}/accessMode/#{bucket}/mode/#{protected_mode})
+        end
+
+        def set_separator(bucket, separator)
+          host = Config.settings[:pub_host]
+          encoded_separator = Utils.urlsafe_base64_encode(separator)
+          Auth.request %Q(#{host}/separator/#{bucket}/sep/#{encoded_separator})
+        end
+
+        def set_style(bucket, name, style)
+          host = Config.settings[:pub_host]
+          encoded_name = Utils.urlsafe_base64_encode(name)
+          encoded_style = Utils.urlsafe_base64_encode(style)
+          Auth.request %Q(#{host}/style/#{bucket}/name/#{encoded_name}/style/#{encoded_style})
+        end
+
+        def unset_style(bucket, name)
+          host = Config.settings[:pub_host]
+          encoded_name = Utils.urlsafe_base64_encode(name)
+          Auth.request %Q(#{host}/unstyle/#{bucket}/name/#{encoded_name})
+        end
+
+      end
+    end
+  end
+end
+

lib/qiniu/rs/rs.rb

@@ -1,69 +1,48 @@
 # -*- encoding: utf-8 -*-
-# vim: sw=2 ts=2
-
-require 'qiniu/http'
 
 module Qiniu
-    module Storage
+  module RS
+    module RS
       class << self
         include Utils
 
-        public
         def buckets
-          url = Config.settings[:rs_host] + '/buckets'
-          return HTTP.management_post(url)
-        end # buckets
+          Auth.request Config.settings[:rs_host] + '/buckets'
+        end
 
-        PRIVATE_BUCKET = 0
-        PUBLIC_BUCKET  = 1
-
-        def mkbucket(bucket_name, is_public = PUBLIC_BUCKET)
-          url = Config.settings[:rs_host] + '/mkbucket2/' + bucket_name + '/public/' + is_public.to_s
-          return HTTP.management_post(url)
-        end # mkbucket
-
-        def make_a_private_bucket(bucket_name)
-          return mkbucket(bucket_name, PRIVATE_BUCKET)
-        end # make_a_private_bucket
-
-        def make_a_public_bucket(bucket_name)
-          return mkbucket(bucket_name, PUBLIC_BUCKET)
-        end # make_a_public_bucket
+        def mkbucket(bucket_name)
+          Auth.request Config.settings[:rs_host] + '/mkbucket/' + bucket_name
+        end
 
         def stat(bucket, key)
-          url = Config.settings[:rs_host] + '/stat/' + encode_entry_uri(bucket, key)
-          return HTTP.management_post(url)
-        end # stat
+          Auth.request Config.settings[:rs_host] + '/stat/' + encode_entry_uri(bucket, key)
+        end
 
         def get(bucket, key, save_as = nil, expires_in = nil, version = nil)
           url = Config.settings[:rs_host] + '/get/' + encode_entry_uri(bucket, key)
           url += '/base/' + version unless version.nil?
           url += '/attName/' + Utils.urlsafe_base64_encode(save_as) unless save_as.nil?
           url += '/expires/' + expires_in.to_s if !expires_in.nil? && expires_in > 0
-          return HTTP.management_post(url)
-        end # get
+          Auth.request url
+        end
 
         def copy(source_bucket, source_key, target_bucket, target_key)
           uri = _generate_cp_or_mv_opstr('copy', source_bucket, source_key, target_bucket, target_key)
-          url = Config.settings[:rs_host] + uri
-          return HTTP.management_post(url)
-        end # copy
+          Auth.request Config.settings[:rs_host] + uri
+        end
 
         def move(source_bucket, source_key, target_bucket, target_key)
           uri = _generate_cp_or_mv_opstr('move', source_bucket, source_key, target_bucket, target_key)
-          url = Config.settings[:rs_host] + uri
-          return HTTP.management_post(url)
-        end # move
+          Auth.request Config.settings[:rs_host] + uri
+        end
 
         def delete(bucket, key)
-          url = Config.settings[:rs_host] + '/delete/' + encode_entry_uri(bucket, key)
-          return HTTP.management_post(url)
-        end # delete
+          Auth.request Config.settings[:rs_host] + '/delete/' + encode_entry_uri(bucket, key)
+        end
 
         def drop(bucket)
-          url = Config.settings[:rs_host] + "/drop/#{bucket}"
-          return HTTP.management_post(url)
-        end # drop
+          Auth.request Config.settings[:rs_host] + "/drop/#{bucket}"
+        end
 
         def batch(command, bucket, keys)
           execs = []
@@ -71,41 +50,40 @@ module Qiniu
             encoded_uri = encode_entry_uri(bucket, key)
             execs << "op=/#{command}/#{encoded_uri}"
           end
-          url = Config.settings[:rs_host] + "/batch"
-          return HTTP.management_post(url, execs.join("&"))
-        end # batch
+          Auth.request Config.settings[:rs_host] + "/batch", execs.join("&"), {:mime => "application/x-www-form-urlencoded" }
+        end
 
         def batch_get(bucket, keys)
           batch("get", bucket, keys)
-        end # batch_get
+        end
 
         def batch_stat(bucket, keys)
           batch("stat", bucket, keys)
-        end # batch_stat
+        end
 
         def batch_copy(*args)
           _batch_cp_or_mv('copy', args)
-        end # batch_copy
+        end
 
         def batch_move(*args)
           _batch_cp_or_mv('move', args)
-        end # batch_move
+        end
 
         def batch_delete(bucket, keys)
           batch("delete", bucket, keys)
-        end # batch_delete
+        end
 
         def save_as(bucket, key, source_url, op_params_string)
           encoded_uri = encode_entry_uri(bucket, key)
           save_as_string = '/save-as/' + encoded_uri
           new_url = source_url + '?' + op_params_string + save_as_string
-          return HTTP.management_post(new_url)
-        end # save_as
+          Auth.request new_url
+        end
 
         def image_mogrify_save_as(bucket, key, source_image_url, options)
-          mogrify_params_string = Fop::Image.generate_mogrify_params_string(options)
+          mogrify_params_string = Image.generate_mogrify_params_string(options)
           save_as(bucket, key, source_image_url, mogrify_params_string)
-        end # image_mogrify_save_as
+        end
 
         private
 
@@ -113,16 +91,17 @@ module Qiniu
           source_encoded_entry_uri = encode_entry_uri(source_bucket, source_key)
           target_encoded_entry_uri = encode_entry_uri(target_bucket, target_key)
           %Q(/#{command}/#{source_encoded_entry_uri}/#{target_encoded_entry_uri})
-        end # _generate_cp_or_mv_opstr
+        end
 
         def _batch_cp_or_mv(command, *op_args)
           execs = []
-          op_args.each do |e| 
+          op_args.each do |e|
             execs << 'op=' + _generate_cp_or_mv_opstr(command, e[0], e[1], e[2], e[3]) if e.size == 4
-          end 
-          url = Config.settings[:rs_host] + "/batch"
-          return HTTP.management_post(url, execs.join("&"))
-        end # _batch_cp_or_mv
+          end
+          Auth.request Config.settings[:rs_host] + "/batch", execs.join("&"), {:mime => "application/x-www-form-urlencoded" }
+        end
+
       end
-    end # module Storage
-end # module Qiniu
+    end
+  end
+end

lib/qiniu/rs/up.rb

@@ -6,44 +6,92 @@ require 'tmpdir'
 require 'fileutils'
 require 'mime/types'
 require 'digest/sha1'
-require 'qiniu/abstract'
-require 'qiniu/exceptions'
+require 'qiniu/rs/abstract'
+require 'qiniu/rs/exceptions'
+require 'qiniu/rs/io'
 
 module Qiniu
-    module Storage
+  module RS
+    module UP
+
+      PROGRESS_TMP_FILE = 'progresses'
+      CHECKSUM_TMP_FILE = 'ctxes'
 
       module AbstractClass
         class ChunkProgressNotifier
-          include Qiniu::Abstract
+          include Qiniu::RS::Abstract
           abstract_methods :notify
           # def notify(block_index, block_put_progress); end
         end
 
         class BlockProgressNotifier
-          include Qiniu::Abstract
+          include Qiniu::RS::Abstract
           abstract_methods :notify
           # def notify(block_index, checksum); end
         end
-      end # module AbstractClass
+      end
 
       class ChunkProgressNotifier < AbstractClass::ChunkProgressNotifier
+          attr_reader :tmpdata
+          def initialize(id)
+              @tmpdata = UP::TmpData.new(id, PROGRESS_TMP_FILE)
+          end
           def notify(index, progress)
+              @tmpdata.set(index, progress)
               logmsg = "chunk #{progress[:offset]/Config.settings[:chunk_size]} in block #{index} successfully uploaded.\n" + progress.to_s
               Utils.debug(logmsg)
           end
-      end # class ChunkProgressNotifier
+      end
 
       class BlockProgressNotifier < AbstractClass::BlockProgressNotifier
+          attr_reader :tmpdata
+          def initialize(id)
+              @tmpdata = UP::TmpData.new(id, CHECKSUM_TMP_FILE)
+          end
           def notify(index, checksum)
+              @tmpdata.set(index, checksum)
               Utils.debug "block #{index}: {ctx: #{checksum}} successfully uploaded."
               Utils.debug "block #{index}: {checksum: #{checksum}} successfully uploaded."
           end
-      end # class BlockProgressNotifier
+      end
+
+      class TmpData
+          def initialize(dir, filename)
+              @tmpdir = Config.settings[:tmpdir] + File::SEPARATOR + dir
+              FileUtils.mkdir_p(@tmpdir) unless File.directory?(@tmpdir)
+              @tmpfile = @tmpdir + File::SEPARATOR + filename
+          end
+
+          def init(values)
+              File.open(@tmpfile, "w") do |f|
+                  YAML::dump(values, f)
+                  Utils.debug %Q(Initializing tmpfile: #{@tmpfile})
+              end
+          end
+
+          def all
+              File.exist?(@tmpfile) ? YAML.load_file(@tmpfile) : []
+          end
+
+          def set(index, value)
+              values = all
+              values[index] = value
+              File.open(@tmpfile, "w") do |f|
+                  YAML::dump(values, f)
+                  Utils.debug %Q(Updating tmpfile: #{@tmpfile})
+              end
+          end
+
+          def sweep!
+              FileUtils.rm_r(@tmpdir) if File.directory?(@tmpdir)
+          end
+      end
+
 
       class << self
         include Utils
 
-        def resumable_upload_with_token(uptoken,
+        def upload_with_token(uptoken,
                               local_file,
                               bucket,
                               key = nil,
@@ -66,7 +114,7 @@ module Qiniu
           ensure
             ifile.close unless ifile.nil?
           end
-        end # resumable_upload_with_token
+        end
 
         private
 
@@ -89,54 +137,42 @@ module Qiniu
                 @fh.mtime
             end
             #delegate :path, :mtime, :to => :fh
-        end # class FileData
+        end
 
         def _new_block_put_progress_data
           {:ctx => nil, :offset => 0, :restsize => nil, :status_code => nil, :host => nil}
-        end # _new_block_put_progress_data
+        end
 
         def _call_binary_with_token(uptoken, url, data, content_type = nil, retry_times = 0)
           options = {
-              :headers => {
-                  :content_type   => 'application/octet-stream',
-                  'Authorization' => 'UpToken ' + uptoken
-              }
+              :method => :post,
+              :content_type => 'application/octet-stream',
+              :upload_signature_token => uptoken
           }
-          if !content_type.nil? && !content_type.empty? then
-              options[:headers][:content_type] = content_type 
-          end
-
-          code, data, raw_headers = HTTP.api_post(url, data, options)
-          unless HTTP.is_response_ok?(code)
+          options[:content_type] = content_type if !content_type.nil? && !content_type.empty?
+          code, data = http_request url, data, options
+          unless Utils.is_response_ok?(code)
               retry_times += 1
               if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
                   return _call_binary_with_token(uptoken, url, data, options[:content_type], retry_times)
               end
           end
-          return code, data, raw_headers
-        end # _call_binary_with_token
+          [code, data]
+        end
 
         def _mkblock(uptoken, block_size, body)
             url = Config.settings[:up_host] + "/mkblk/#{block_size}"
             _call_binary_with_token(uptoken, url, body)
-        end # _mkblock
+        end
 
         def _putblock(uphost, uptoken, ctx, offset, body)
             url = uphost + "/bput/#{ctx}/#{offset}"
             _call_binary_with_token(uptoken, url, body)
-        end # _putblock
+        end
 
-        def _resumable_put_block(uptoken,
-                                 fh,
-                                 block_index,
-                                 block_size,
-                                 chunk_size,
-                                 progress,
-                                 retry_times,
-                                 notifier)
+        def _resumable_put_block(uptoken, fh, block_index, block_size, chunk_size, progress, retry_times, notifier)
             code, data = 0, {}
             fpath = fh.path
-
             # this block has never been uploaded.
             if progress[:ctx] == nil || progress[:ctx].empty?
                 progress[:offset] = 0
@@ -150,12 +186,9 @@ module Qiniu
                     if result_length != body_length
                         raise FileSeekReadError.new(fpath, block_index, seek_pos, body_length, result_length)
                     end
-
-                    code, data, raw_headers = _mkblock(uptoken, block_size, body)
-                    Utils.debug "Mkblk : #{code.inspect} #{data.inspect} #{raw_headers.inspect}"
-
+                    code, data = _mkblock(uptoken, block_size, body)
                     body_crc32 = Zlib.crc32(body)
-                    if HTTP.is_response_ok?(code) && data["crc32"] == body_crc32
+                    if Utils.is_response_ok?(code) && data["crc32"] == body_crc32
                         progress[:ctx] = data["ctx"]
                         progress[:offset] = body_length
                         progress[:restsize] = block_size - body_length
@@ -167,13 +200,13 @@ module Qiniu
                         break
                     elsif i == retry_times && data["crc32"] != body_crc32
                         Log.logger.error %Q(Uploading block error. Expected crc32: #{body_crc32}, but got: #{data["crc32"]})
-                        return code, data, raw_headers
+                        # 上传重试达到上限，直接返回错误
+                        return [code, data]
                     end
                 end
             elsif progress[:offset] + progress[:restsize] != block_size
                 raise BlockSizeNotMathchError.new(fpath, block_index, progress[:offset], progress[:restsize], block_size)
             end
-
             # loop uploading other chunks except the first one
             while progress[:restsize].to_i > 0 && progress[:restsize] < block_size
                 # choose the smaller one
@@ -185,12 +218,9 @@ module Qiniu
                     if result_length != body_length
                         raise FileSeekReadError.new(fpath, block_index, seek_pos, body_length, result_length)
                     end
-
-                    code, data, raw_headers = _putblock(progress[:host], uptoken, progress[:ctx], progress[:offset], body)
-                    Utils.debug "Bput : #{code.inspect} #{data.inspect} #{raw_headers.inspect}"
-
+                    code, data = _putblock(progress[:host], uptoken, progress[:ctx], progress[:offset], body)
                     body_crc32 = Zlib.crc32(body)
-                    if HTTP.is_response_ok?(code) && data["crc32"] == body_crc32
+                    if Utils.is_response_ok?(code) && data["crc32"] == body_crc32
                         progress[:ctx] = data["ctx"]
                         progress[:offset] += body_length
                         progress[:restsize] -= body_length
@@ -202,24 +232,20 @@ module Qiniu
                         break
                     elsif i == retry_times && data["crc32"] != body_crc32
                         Log.logger.error %Q(Uploading block error. Expected crc32: #{body_crc32}, but got: #{data["crc32"]})
-                        return code, data, raw_headers
+                        # 上传重试达到上限，直接返回错误
+                        return [code, data]
                     end
                 end
             end
             # return
-            return code, data, raw_headers
-        end # _resumable_put_block
+            return [code, data]
+        end
 
         def _block_count(fsize)
             ((fsize + Config.settings[:block_size] - 1) / Config.settings[:block_size]).to_i
-        end # _block_count
+        end
 
-        def _resumable_put(uptoken,
-                           fh,
-                           checksums,
-                           progresses,
-                           block_notifier = nil,
-                           chunk_notifier = nil)
+        def _resumable_put(uptoken, fh, checksums, progresses, block_notifier = nil, chunk_notifier = nil)
             code, data = 0, {}
             fsize = fh.data_size
             block_count = _block_count(fsize)
@@ -237,10 +263,8 @@ module Qiniu
                     if progresses[block_index].nil?
                         progresses[block_index] = _new_block_put_progress_data
                     end
-                    #code, data = _resumable_put_block(uptoken, fh, block_index, block_size, Config.settings[:chunk_size], progresses[block_index], Config.settings[:max_retry_times], chunk_notifier)
-                    # Put the whole block as a chunk
-                    code, data = _resumable_put_block(uptoken, fh, block_index, block_size, block_size, progresses[block_index], Config.settings[:max_retry_times], chunk_notifier)
-                    if HTTP.is_response_ok?(code)
+                    code, data = _resumable_put_block(uptoken, fh, block_index, block_size, Config.settings[:chunk_size], progresses[block_index], Config.settings[:max_retry_times], chunk_notifier)
+                    if Utils.is_response_ok?(code)
                         #checksums[block_index] = data["checksum"]
                         checksums[block_index] = data["ctx"]
                         if !block_notifier.nil? && block_notifier.respond_to?("notify")
@@ -250,23 +274,14 @@ module Qiniu
                 end
             end
             return [code, data]
-        end # _resumable_put
+        end
 
-        def _mkfile(uphost,
-                    uptoken,
-                    entry_uri,
-                    fsize,
-                    checksums,
-                    mime_type = nil,
-                    custom_meta = nil,
-                    customer = nil,
-                    callback_params = nil,
-                    rotate = nil)
+        def _mkfile(uphost, uptoken, entry_uri, fsize, checksums, mime_type = nil, custom_meta = nil, customer = nil, callback_params = nil, rotate = nil)
           path = '/rs-mkfile/' + Utils.urlsafe_base64_encode(entry_uri) + "/fsize/#{fsize}"
           path += '/mimeType/' + Utils.urlsafe_base64_encode(mime_type) if !mime_type.nil? && !mime_type.empty?
           path += '/meta/' + Utils.urlsafe_base64_encode(custom_meta) if !custom_meta.nil? && !custom_meta.empty?
           path += '/customer/' + customer if !customer.nil? && !customer.empty?
-          callback_query_string = HTTP.generate_query_string(callback_params) if !callback_params.nil? && !callback_params.empty?
+          callback_query_string = Utils.generate_query_string(callback_params) if !callback_params.nil? && !callback_params.empty?
           path += '/params/' + Utils.urlsafe_base64_encode(callback_query_string) if !callback_query_string.nil? && !callback_query_string.empty?
           path += '/rotate/' + rotate if !rotate.nil? && rotate.to_i >= 0
           url = uphost + path
@@ -276,44 +291,38 @@ module Qiniu
           #end
           body = checksums.join(',')
           _call_binary_with_token(uptoken, url, body, 'text/plain')
-        end # _mkfile
-
-        def _resumable_upload(uptoken,
-                              fh,
-                              fsize,
-                              bucket,
-                              key,
-                              mime_type = nil,
-                              custom_meta = nil,
-                              customer = nil,
-                              callback_params = nil,
-                              rotate = nil)
+        end
 
+        def _resumable_upload(uptoken, fh, fsize, bucket, key, mime_type = nil, custom_meta = nil, customer = nil, callback_params = nil, rotate = nil)
           block_count = _block_count(fsize)
-
-          chunk_notifier = ChunkProgressNotifier.new()
-          block_notifier = BlockProgressNotifier.new()
-
-          progresses = []
-          block_count.times{progresses << _new_block_put_progress_data}
-          checksums = []
-          block_count.times{checksums << ''}
-
-          code, data, raw_headers = _resumable_put(uptoken, fh, checksums, progresses, block_notifier, chunk_notifier)
-
-          if HTTP.is_response_ok?(code)
+          chunk_notifier = ChunkProgressNotifier.new(key)
+          block_notifier = BlockProgressNotifier.new(key)
+          progresses = chunk_notifier.tmpdata.all
+          if progresses.empty?
+              block_count.times{progresses << _new_block_put_progress_data}
+              chunk_notifier.tmpdata.init(progresses)
+          end
+          checksums = block_notifier.tmpdata.all
+          if checksums.empty?
+              block_count.times{checksums << ''}
+              block_notifier.tmpdata.init(checksums)
+          end
+          code, data = _resumable_put(uptoken, fh, checksums, progresses, block_notifier, chunk_notifier)
+          if Utils.is_response_ok?(code)
             uphost = data["host"]
             entry_uri = bucket + ':' + key
-            code, data, raw_headers = _mkfile(uphost, uptoken, entry_uri, fsize, checksums, mime_type, custom_meta, customer, callback_params, rotate)
-            Utils.debug "Mkfile : #{code.inspect} #{data.inspect} #{raw_headers.inspect}"
+            code, data = _mkfile(uphost, uptoken, entry_uri, fsize, checksums, mime_type, custom_meta, customer, callback_params, rotate)
           end
-
-          if HTTP.is_response_ok?(code)
+          if Utils.is_response_ok?(code)
             Utils.debug "File #{fh.path} {size: #{fsize}} successfully uploaded."
+            chunk_notifier.tmpdata.sweep!
+            block_notifier.tmpdata.sweep!
           end
+          [code, data]
+        end
 
-          return code, data, raw_headers
-        end # _resumable_upload
-      end # self class
-    end # module Storage
-end # module Qiniu
+      end
+
+    end
+  end
+end

lib/qiniu/rs/utils.rb

@@ -7,9 +7,10 @@ require 'zlib'
 require 'base64'
 require 'rest_client'
 require 'hmac-sha1'
-require 'qiniu/exceptions'
+require 'qiniu/rs/exceptions'
 
 module Qiniu
+  module RS
     module Utils extend self
 
       def urlsafe_base64_encode content
@@ -31,13 +32,20 @@ module Qiniu
         {}
       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]
@@ -62,18 +70,16 @@ module Qiniu
           response = RestClient.post(url, data, header_options)
         end
         code = response.respond_to?(:code) ? response.code.to_i : 0
-        unless HTTP.is_response_ok?(code)
+        unless 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
+        [code, data]
+      end
 
-      ### 已过时，仅作为兼容接口保留
       def http_request url, data = nil, options = {}
         retry_times = 0
         begin
@@ -94,16 +100,54 @@ module Qiniu
             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]
+          [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
 
-    end # module Utils
-end # module Qiniu
+      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
+  end
+end

lib/qiniu/rs/version.rb

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

lib/qiniu/storage.rb

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

lib/qiniu/tokens/access_token.rb

@@ -1,10 +1,11 @@
 # -*- encoding: utf-8 -*-
 
 require 'hmac-sha1'
-require 'qiniu/config'
-require 'qiniu/utils'
+require 'qiniu/rs/config'
+require 'qiniu/rs/utils'
 
 module Qiniu
+  module RS
       class AccessToken
 
         include Utils
@@ -17,5 +18,6 @@ module Qiniu
           urlsafe_base64_encode(hmac.digest)
         end
 
-      end # AccessToken
-end # module Qiniu
+      end
+  end
+end

lib/qiniu/tokens/download_token.rb

@@ -2,9 +2,10 @@
 
 require 'json'
 require 'qiniu/tokens/access_token'
-require 'qiniu/utils'
+require 'qiniu/rs/utils'
 
 module Qiniu
+  module RS
       class DownloadToken < AccessToken
 
         include Utils
@@ -27,5 +28,6 @@ module Qiniu
           %Q(#{@access_key}:#{encoded_digest}:#{signature})
         end
 
-      end # moidule DownloadToken
-end # module Qiniu
+      end
+  end
+end

lib/qiniu/tokens/qbox_token.rb

@@ -5,6 +5,7 @@ require 'json'
 require 'qiniu/tokens/access_token'
 
 module Qiniu
+  module RS
       class QboxToken < AccessToken
 
         include Utils
@@ -23,7 +24,7 @@ module Qiniu
           signature += '?' + query_string if !query_string.nil? && !query_string.empty?
           signature += "\n"
           if @params.is_a?(Hash)
-              params_string = HTTP.generate_query_string(@params)
+              params_string = Utils.generate_query_string(@params)
               signature += params_string
           end
           signature
@@ -34,5 +35,6 @@ module Qiniu
           %Q(#{@access_key}:#{encoded_digest})
         end
 
-      end # module QboxToken
-end # module Qiniu
+      end
+  end
+end

lib/qiniu/tokens/upload_token.rb

@@ -2,9 +2,10 @@
 
 require 'json'
 require 'qiniu/tokens/access_token'
-require 'qiniu/utils'
+require 'qiniu/rs/utils'
 
 module Qiniu
+  module RS
       class UploadToken < AccessToken
 
         include Utils
@@ -43,5 +44,6 @@ module Qiniu
           %Q(#{@access_key}:#{encoded_digest}:#{signature})
         end
 
-      end # module UploadToken
-end # module Qiniu
+      end
+  end
+end

lib/qiniu/upload.rb

@@ -1,125 +0,0 @@
-# -*- 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)
-        ### 构造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
-
-        ### 发送请求
-        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)
-        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)
-      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

qiniu-rs.gemspec

@@ -1,21 +1,20 @@
 # -*- encoding: utf-8 -*-
 
-require File.expand_path('../lib/qiniu/version', __FILE__)
+require File.expand_path('../lib/qiniu/rs/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["why404","BluntBlade"]
+  gem.authors       = ["why404"]
   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.description   = %q{Deprecated Qiniu Resource (Cloud) Storage SDK for Ruby. Please use new SDK https://rubygems.org/gems/qiniu}
+  gem.summary       = %q{Deprecated Qiniu Resource (Cloud) Storage SDK for Ruby}
+  gem.homepage      = "https://github.com/qiniu/ruby-sdk/tree/qiniu-rs"
 
   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.name          = "qiniu-rs"
   gem.require_paths = ["lib"]
-  gem.version       = Qiniu::Version.to_s
-  gem.license       = "MIT"
+  gem.version       = Qiniu::RS::Version.to_s
 
   # specify any dependencies here; for example:
   gem.add_development_dependency "rake", ">= 0.9"

spec/qiniu/auth_spec.rb

@@ -1,75 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu/storage'
-require 'digest/sha1'
-
-module Qiniu
-  module Auth 
-    describe Auth do
-
-      before :all do
-        @bucket = 'RubySDK-Test-Private'
-        @bucket = make_unique_bucket(@bucket)
-
-        ### 尝试创建Bucket
-        result = Qiniu::Storage.make_a_private_bucket(@bucket)
-        puts result.inspect
-      end
-
-      after :all do
-        ### 不删除Bucket以备下次使用
-      end
-
-      ### 测试私有资源下载
-      context ".download_private_file" do
-        it "should works" do
-          ### 生成Key
-          key = 'a_private_file'
-          key = make_unique_key_in_bucket(key)
-          puts "key=#{key}"
-
-          ### 上传测试文件
-          pp = Auth::PutPolicy.new(@bucket, key)
-          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
-            pp,
-            __FILE__
-          )
-          code.should == 200
-          puts data.inspect
-          puts raw_headers.inspect
-
-          ### 获取下载地址
-          code, data = Qiniu::Storage.get(@bucket, key)
-          code.should == 200
-          puts data.inspect
-
-          url = data['url']
-
-          ### 授权下载地址（不带参数）
-          download_url = Qiniu::Auth.authorize_download_url(url)
-          puts "download_url=#{download_url}"
-
-          result = RestClient.get(download_url)
-          result.code.should == 200
-          result.body.should_not be_empty
-
-          ### 授权下载地址（带参数）
-          download_url = Qiniu::Auth.authorize_download_url(url + '?download/a.m3u8')
-          puts "download_url=#{download_url}"
-
-          result = RestClient.get(download_url)
-          result.code.should == 200
-          result.body.should_not be_empty
-
-          ### 删除文件
-          code, data = Qiniu::Storage.delete(@bucket, key)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-    end
-  end # module Storage
-end # module Qiniu

spec/qiniu/management_spec.rb

@@ -1,156 +0,0 @@
-# -*- encoding: utf-8 -*-
-# vim: sw=2 ts=2
-
-require 'digest/sha1'
-require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu/management'
-require 'qiniu'
-
-module Qiniu
-  module Storage
-    describe Storage do
-
-      before :all do
-        @bucket = 'RubySDK-Test-Management'
-        @bucket = make_unique_bucket(@bucket)
-
-        ### 尝试创建Bucket
-        result = Qiniu.mkbucket(@bucket)
-        puts result.inspect
-
-        @key = Digest::SHA1.hexdigest((Time.now.to_i+rand(100)).to_s)
-        @key = make_unique_key_in_bucket(@key)
-
-        @key2 = @key + rand(100).to_s
-      end
-
-      after :all do
-        ### 不删除Bucket以备下次使用
-      end
-
-      ### 准备数据
-      context ".prepare_file" do
-        it "should works" do
-          pp = Auth::PutPolicy.new(@bucket, @key)
-          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
-            pp,
-            __FILE__
-          )
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      ### 列举Bucket
-      context ".buckets" do
-        it "should works" do
-          code, data = Storage.buckets
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".stat" do
-        it "should works" do
-          code, data = Storage.stat(@bucket, @key)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".get" do
-        it "should works" do
-          code, data = Storage.get(@bucket, @key)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".batch" do
-        it "should works" do
-          code, data = Storage.batch("stat", @bucket, [@key])
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".batch_stat" do
-        it "should works" do
-          code, data = Storage.batch_stat(@bucket, [@key])
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".batch_get" do
-        it "should works" do
-          code, data = Storage.batch_get(@bucket, [@key])
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".batch_copy" do
-        it "should works" do
-          code, data = Storage.batch_copy @bucket, @key, @bucket, @key2
-          code.should == 200
-          puts data.inspect
-
-          code, data = Storage.delete @bucket, @key2
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".batch_move" do
-        it "should works" do
-          code, data = Storage.batch_move @bucket, @key, @bucket, @key2
-          code.should == 200
-          puts data.inspect
-
-          code3, data3 = Storage.batch_move @bucket, @key2, @bucket, @key
-          code3.should == 200
-          puts data3.inspect
-        end
-      end
-
-      context ".move" do
-        it "should works" do
-          code, data = Storage.move(@bucket, @key, @bucket, @key2)
-          code.should == 200
-          puts data.inspect
-
-          code2, data2 = Storage.stat(@bucket, @key2)
-          code2.should == 200
-          puts data2.inspect
-
-          code3, data3 = Storage.move(@bucket, @key2, @bucket, @key)
-          code3.should == 200
-          puts data3.inspect
-        end
-      end
-
-      context ".copy" do
-        it "should works" do
-          code, data = Storage.copy(@bucket, @key, @bucket, @key2)
-          code.should == 200
-          puts data.inspect
-
-          code, data = Storage.delete(@bucket, @key2)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Storage.delete(@bucket, @key)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-
-    end
-  end # module Storage
-end # module Qiniu

spec/qiniu/pfop_spec.rb

@@ -1,89 +0,0 @@
-# -*- encoding: utf-8 -*-
-# vim: sw=2 ts=2
-
-require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu'
-require 'qiniu/fop'
-
-module Qiniu
-  module Fop
-    module Persistance
-      describe Persistance do
-
-        before :all do
-          ### 复用RubySDK-Test-Storage空间
-          @bucket = 'RubySDK-Test-Storage'
-          @bucket = make_unique_bucket(@bucket)
-
-          ### 尝试创建空间
-          code, data, headers = Qiniu::Storage.make_a_public_bucket(@bucket)
-          puts code.inspect
-          puts data.inspect
-          puts headers.inspect
-
-          pic_fname = "image_logo_for_test.png"
-          @key = make_unique_key_in_bucket(pic_fname)
-
-          local_file = File.expand_path('../' + pic_fname, __FILE__)
-
-          ### 检查测试文件存在性
-          code, body, headers = Qiniu::Storage.stat(@bucket, @key)
-          if code == 404 || code == 612 then
-            # 文件不存在，尝试上传
-            pp = Qiniu::Auth.PutPolicy.new(@bucket, @key)
-            code, body, headers = Qiniu::Storage.upload_with_put_policy(
-              pp,
-              local_file
-            )
-            puts "Put a test file for Persistance cases"
-            puts code.inspect
-            puts body.inspect
-            puts header.inspect
-          end
-        end
-
-        after :all do
-          ### 不删除Bucket以备下次使用
-        end
-
-        context ".pfop" do
-          it "should works" do
-            pp = Persistance::PfopPolicy.new(
-              @bucket,
-              @key,
-              'imageView2/1/w/80/h/80',   # fops
-              'www.baidu.com'             # notify_url
-            )
-
-            code, data, headers = Qiniu::Fop::Persistance.pfop(pp)
-            code.should == 200
-            puts data.inspect
-          end
-        end
-
-        context ".prefop" do
-          it "should works" do
-            code, data, headers = Qiniu::Fop::Persistance.prefop('fakePersistentId')
-            code.should == 612
-            puts code.inspect
-            puts data.inspect
-            puts headers.inspect
-          end
-        end
-
-        context ".p1" do
-          it "should works" do
-            url = 'http://fake.qiniudn.com/fake.jpg'
-            fop = 'imageView2/1/w/80/h/80'
-            target_url = "#{url}?p/1/#{CGI.escape(fop).gsub('+', '%20')}"
-
-            p1_url = Qiniu::Fop::Persistance.generate_p1_url(url, fop)
-            p1_url.should == target_url
-            puts p1_url.inspect
-          end
-        end
-      end
-    end # module Persistance
-  end # module Fop
-end # module Qiniu

spec/qiniu/rs/abstract_spec.rb

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
 
 require 'spec_helper'
-require 'qiniu/abstract'
+require 'qiniu/rs/abstract'
 
-describe Qiniu::Abstract do
+describe Qiniu::RS::Abstract do
   before(:each) do
     @klass = Class.new do
-      include Qiniu::Abstract
+      include Qiniu::RS::Abstract
 
       abstract_methods :foo, :bar
     end

spec/qiniu/rs/eu_spec.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs'
+require 'qiniu/rs/pub'
+require 'qiniu/rs/eu'
+
+module Qiniu
+  module RS
+    describe EU do
+
+      before :all do
+        @customer_id = "why404@gmail.com"
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        @key = "image_logo_for_test.png"
+
+        result = Qiniu::RS.mkbucket(@bucket)
+        puts result.inspect
+        result.should be_true
+
+        local_file = File.expand_path('../' + @key, __FILE__)
+        upopts = {:scope => @bucket, :expires_in => 3600, :customer => @customer_id}
+        uptoken = Qiniu::RS.generate_upload_token(upopts)
+
+        data = Qiniu::RS.upload_file :uptoken => uptoken, :file => local_file, :bucket => @bucket, :key => @key
+        puts data.inspect
+
+        code2, data2 = Qiniu::RS::Pub.set_separator(@bucket, "-")
+        code2.should == 200
+        puts data2.inspect
+
+        code3, data3 = Qiniu::RS::Pub.set_style(@bucket, "small.jpg", "imageView/1/w/120/h/120/q/85/format/jpg/watermark/1")
+        code3.should == 200
+        puts data3.inspect
+      end
+
+      after :all do
+        result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
+        result.should_not be_false
+      end
+
+=begin
+      context ".set_watermark" do
+        it "should works" do
+          options = {
+            :text => "Powered by QiniuRS"
+          }
+          code, data = Qiniu::RS::EU.set_watermark(@customer_id, options)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".get_watermark" do
+        it "should works" do
+          code, data = Qiniu::RS::EU.get_watermark(@customer_id)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+=end
+
+    end
+  end
+end

spec/qiniu/rs/image_spec.rb

@@ -1,28 +1,24 @@
 # -*- encoding: utf-8 -*-
 
 require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu'
-require 'qiniu/fop'
+require 'qiniu/rs/auth'
+require 'qiniu/rs'
+require 'qiniu/rs/image'
 
 module Qiniu
-    module Fop
-    describe Fop do
+  module RS
+    describe Image do
 
       before :all do
 
-        ### 复用RubySDK-Test-Storage空间
-        @bucket = 'RubySDK-Test-Storage'
-        @bucket = make_unique_bucket(@bucket)
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        @key = "image_logo_for_test.png"
 
-        ### 尝试创建空间
-        result = Qiniu.mkbucket(@bucket)
+        result = Qiniu::RS.mkbucket(@bucket)
         puts result.inspect
+        result.should be_true
 
-        pic_fname = "image_logo_for_test.png"
-        @key = make_unique_key_in_bucket(pic_fname)
-
-        local_file = File.expand_path('../' + pic_fname, __FILE__)
+        local_file = File.expand_path('../' + @key, __FILE__)
 
         upopts = {
             :scope => @bucket,
@@ -31,8 +27,8 @@ module Qiniu
             :async_options => "imageView/1/w/120/h/120",
             :return_body => '{"size":$(fsize), "hash":$(etag), "width":$(imageInfo.width), "height":$(imageInfo.height)}'
         }
-        uptoken = Qiniu.generate_upload_token(upopts)
-        data = Qiniu.upload_file :uptoken => uptoken, :file => local_file, :bucket => @bucket, :key => @key
+        uptoken = Qiniu::RS.generate_upload_token(upopts)
+        data = Qiniu::RS.upload_file :uptoken => uptoken, :file => local_file, :bucket => @bucket, :key => @key
         puts data.inspect
 
         data["size"].should_not be_zero
@@ -40,7 +36,7 @@ module Qiniu
         data["width"].should_not be_zero
         data["height"].should_not be_zero
 
-        result = Qiniu.get(@bucket, @key)
+        result = Qiniu::RS.get(@bucket, @key)
         result["url"].should_not be_empty
         puts result.inspect
         @source_image_url = result["url"]
@@ -57,33 +53,33 @@ module Qiniu
       end
 
       after :all do
-        ### 不删除Bucket以备下次使用
+        result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
+        result.should_not be_false
       end
 
       context ".info" do
         it "should works" do
-          code, data = Qiniu::Fop::Image.info(@source_image_url)
+          code, data = Qiniu::RS::Image.info(@source_image_url)
           code.should == 200
           puts data.inspect
         end
       end
 
-=begin
       context ".exif" do
         it "should works" do
-          code, data = Qiniu::Fop::Image.exif(@source_image_url)
+          code, data = Qiniu::RS::Image.exif(@source_image_url)
           puts data.inspect
         end
       end
-=end
 
       context ".mogrify_preview_url" do
         it "should works" do
-          mogrify_preview_url = Qiniu::Fop::Image.mogrify_preview_url(@source_image_url, @mogrify_options)
+          mogrify_preview_url = Qiniu::RS::Image.mogrify_preview_url(@source_image_url, @mogrify_options)
           puts mogrify_preview_url.inspect
         end
       end
 
     end
-    end # module Fop
-end # module Qiniu
+  end
+end

spec/qiniu/rs/io_spec.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs/auth'
+require 'qiniu/rs/io'
+require 'digest/sha1'
+
+module Qiniu
+  module RS
+    describe IO do
+
+      before :all do
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        @key = Digest::SHA1.hexdigest((Time.now.to_i+rand(100)).to_s)
+
+        result = Qiniu::RS.mkbucket(@bucket)
+        puts result.inspect
+        result.should be_true
+      end
+
+      after :all do
+        result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
+        result.should_not be_false
+      end
+
+      context ".upload_file" do
+        it "should works" do
+          code, data = Qiniu::RS::IO.put_auth()
+          code.should == 200
+          data["url"].should_not be_empty
+          data["expiresIn"].should_not be_zero
+          puts data.inspect
+          code2, data2 = Qiniu::RS::IO.upload_file(data["url"], __FILE__, @bucket, @key)
+          code2.should == 200
+          puts data2.inspect
+        end
+      end
+
+      context ".put_file" do
+        it "should works" do
+          code, data = Qiniu::RS::IO.put_file(__FILE__, @bucket, @key, 'application/x-ruby', 'customMeta', true)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".upload_with_token" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu::RS.generate_upload_token(upopts)
+          code, data = Qiniu::RS::IO.upload_with_token(uptoken, __FILE__, @bucket, @key, nil, nil, nil, true)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

spec/qiniu/rs/pub_spec.rb

@@ -1,30 +1,30 @@
 # -*- encoding: utf-8 -*-
 
 require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu'
-require 'qiniu/misc'
+require 'qiniu/rs/auth'
+require 'qiniu/rs/rs'
+require 'qiniu/rs/pub'
 
 module Qiniu
-  module Misc
-    describe Misc do
+  module RS
+    describe Pub do
 
       before :all do
-        ### 复用RubySDK-Test-Management空间
-        @bucket = 'RubySDK-Test-Management'
-        @bucket = make_unique_bucket(@bucket)
-
-        result = Qiniu.mkbucket(@bucket)
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        result = Qiniu::RS.mkbucket(@bucket)
         puts result.inspect
+        result.should_not be_false
       end
 
       after :all do
-        ### 不删除Bucket以备下次使用
+        result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
+        result.should_not be_false
       end
 
       context ".set_protected" do
         it "should works" do
-          code, data = Qiniu::Misc.set_protected(@bucket, 1)
+          code, data = Qiniu::RS::Pub.set_protected(@bucket, 1)
           code.should == 200
           puts data.inspect
         end
@@ -32,7 +32,7 @@ module Qiniu
 
       context ".set_separator" do
         it "should works" do
-          code, data = Qiniu::Misc.set_separator(@bucket, "-")
+          code, data = Qiniu::RS::Pub.set_separator(@bucket, "-")
           code.should == 200
           puts data.inspect
         end
@@ -40,7 +40,7 @@ module Qiniu
 
       context ".set_style" do
         it "should works" do
-          code, data = Qiniu::Misc.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
+          code, data = Qiniu::RS::Pub.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
           code.should == 200
           puts data.inspect
         end
@@ -48,12 +48,12 @@ module Qiniu
 
       context ".unset_style" do
         it "should works" do
-          code, data = Qiniu::Misc.unset_style(@bucket, "small.jpg")
+          code, data = Qiniu::RS::Pub.unset_style(@bucket, "small.jpg")
           code.should == 200
           puts data.inspect
         end
       end
 
     end
-  end # module Misc
-end # module Qiniu
+  end
+end

spec/qiniu/rs/rs_spec.rb

@@ -0,0 +1,172 @@
+# -*- encoding: utf-8 -*-
+
+require 'digest/sha1'
+require 'spec_helper'
+require 'qiniu/rs/auth'
+require 'qiniu/rs/io'
+require 'qiniu/rs/rs'
+
+module Qiniu
+  module RS
+    describe RS do
+
+      before :all do
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        @key = Digest::SHA1.hexdigest((Time.now.to_i+rand(100)).to_s)
+        @key2 = @key + rand(100).to_s
+        #@domain = @bucket + '.dn.qbox.me'
+
+        code, data = Qiniu::RS::RS.mkbucket(@bucket)
+        puts [code, data].inspect
+        code.should == 200
+      end
+
+      after :all do
+        code, data = Qiniu::RS::RS.drop(@bucket)
+        puts [code, data].inspect
+        code.should == 200
+      end
+
+      context "IO.upload_file" do
+        it "should works" do
+          code, data = Qiniu::RS::IO.put_auth()
+          puts data.inspect
+          code.should == 200
+          data["url"].should_not be_empty
+          data["expiresIn"].should_not be_zero
+          @put_url = data["url"]
+
+          code2, data2 = Qiniu::RS::IO.upload_file(@put_url, __FILE__, @bucket, @key)
+          puts data2.inspect
+          code2.should == 200
+        end
+      end
+
+      context ".buckets" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.buckets
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".stat" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.stat(@bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".get" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.get(@bucket, @key, "rs_spec.rb", 1)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.batch("stat", @bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch_stat" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.batch_stat(@bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch_get" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.batch_get(@bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch_copy" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.batch_copy @bucket, @key, @bucket, @key2
+          code.should == 200
+          puts data.inspect
+
+          #code2, data2 = Qiniu::RS::RS.stat(@bucket, @key2)
+          #code2.should == 200
+          #puts data2.inspect
+          #
+          code, data = Qiniu::RS::RS.delete(@bucket, @key2)
+          code.should == 200
+          puts data.inspect
+
+        end
+      end
+
+      context ".batch_move" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.batch_move @bucket, @key, @bucket, @key2
+          code.should == 200
+          puts data.inspect
+
+          #code2, data2 = Qiniu::RS::RS.stat(@bucket, @key2)
+          #code2.should == 200
+          #puts data2.inspect
+
+          code3, data3 = Qiniu::RS::RS.batch_move @bucket, @key2, @bucket, @key
+          code3.should == 200
+          puts data3.inspect
+        end
+      end
+
+      context ".move" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.move(@bucket, @key, @bucket, @key2)
+          code.should == 200
+          puts data.inspect
+
+          code2, data2 = Qiniu::RS::RS.stat(@bucket, @key2)
+          code2.should == 200
+          puts data2.inspect
+
+          code3, data3 = Qiniu::RS::RS.move(@bucket, @key2, @bucket, @key)
+          code3.should == 200
+          puts data3.inspect
+        end
+      end
+
+      context ".copy" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.copy(@bucket, @key, @bucket, @key2)
+          code.should == 200
+          puts data.inspect
+
+          #code2, data2 = Qiniu::RS::RS.stat(@bucket, @key2)
+          #code2.should == 200
+          #puts data2.inspect
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.delete(@bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".drop" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.drop(@bucket)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

spec/qiniu/rs/up_spec.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require 'digest/sha1'
+require 'spec_helper'
+require 'qiniu/rs/rs'
+require 'qiniu/rs/up'
+
+module Qiniu
+  module RS
+    describe UP do
+
+      before :all do
+        @localfile = "bigfile.txt"
+        File.open(@localfile, "w"){|f| 5242888.times{f.write(rand(9).to_s)}}
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        @key = Digest::SHA1.hexdigest(@localfile+Time.now.to_s)
+
+        code, data = Qiniu::RS::RS.mkbucket(@bucket)
+        puts [code, data].inspect
+        code.should == 200
+      end
+
+      after :all do
+        File.unlink(@localfile) if File.exists?(@localfile)
+
+        code, data = Qiniu::RS::RS.drop(@bucket)
+        puts [code, data].inspect
+        code.should == 200
+      end
+
+      context ".upload_with_token" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
+          uptoken = Qiniu::RS.generate_upload_token(upopts)
+          code, data = Qiniu::RS::UP.upload_with_token(uptoken, @localfile, @bucket, @key)
+          puts data.inspect
+          (code/100).should == 2
+        end
+      end
+
+      context ".stat" do
+        it "should exists" do
+          code, data = Qiniu::RS::RS.stat(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.delete(@bucket, @key)
+          puts data.inspect
+          code.should == 200
+        end
+      end
+
+    end
+  end
+end

spec/qiniu/rs/utils_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'fakeweb'
-require 'qiniu/utils'
+require 'qiniu/rs/utils'
 
 module Qiniu
   module RS
@@ -28,7 +28,7 @@ module Qiniu
           FakeWeb.allow_net_connect = false
           FakeWeb.register_uri(:get, "http://docs.qiniutek.com/", :body => {:abc => 123}.to_json)
           res = Utils.send_request_with 'http://docs.qiniutek.com/', nil, :method => :get
-          res.should == [200, {"abc" => 123}, {}]
+          res.should == [200, {"abc" => 123}]
         end
 
         [400, 500].each do |code|

spec/qiniu/rs/version_spec.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs/version'
+
+describe Qiniu::RS::Version do
+  it "should has a VERSION" do
+    Qiniu::RS::Version.to_s.should =~ /^\d+\.\d+\.\d+?$/
+  end
+end

spec/qiniu/rs_spec.rb

@@ -2,44 +2,48 @@
 
 require 'digest/sha1'
 require 'spec_helper'
-require 'qiniu'
-require 'qiniu/exceptions'
+require 'qiniu/rs'
+require 'qiniu/rs/exceptions'
 
 module Qiniu
-  describe Qiniu do
+  describe RS do
 
     before :all do
-      @bucket = 'RubySDK-Test'
-      @bucket = make_unique_bucket(@bucket)
-
-      @test_image_bucket = @bucket
-
-      ### 尝试创建Bucket
-      result = Qiniu.mkbucket(@bucket)
-      puts result.inspect
-
+      @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
       @key = Digest::SHA1.hexdigest Time.now.to_s
-      @key = make_unique_key_in_bucket(@key)
-
       @key2 = @key + rand(100).to_s
       #@domain = @bucket + '.dn.qbox.me'
 
+      result = Qiniu::RS.mkbucket(@bucket)
+      result.should_not be_false
+
+      @test_image_bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+      result2 = Qiniu::RS.mkbucket(@test_image_bucket)
+      puts result2.inspect
+      result2.should be_true
+
       @test_image_key = 'image_logo_for_test.png'
-      local_file = File.expand_path('./' + @test_image_key, File.dirname(__FILE__))
+      local_file = File.expand_path('./rs/' + @test_image_key, File.dirname(__FILE__))
       puts local_file.inspect
       upopts = {:scope => @test_image_bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-      uptoken = Qiniu.generate_upload_token(upopts)
-      data = Qiniu.upload_file :uptoken => uptoken, :file => local_file, :bucket => @test_image_bucket, :key => @test_image_key
+      uptoken = Qiniu::RS.generate_upload_token(upopts)
+      data = Qiniu::RS.upload_file :uptoken => uptoken, :file => local_file, :bucket => @test_image_bucket, :key => @test_image_key
       puts data.inspect
     end
 
     after :all do
-      ### 不删除Bucket以备下次使用
+      result1 = Qiniu::RS.drop(@bucket)
+      puts result1.inspect
+      result1.should_not be_false
+
+      result2 = Qiniu::RS.drop(@test_image_bucket)
+      puts result2.inspect
+      result2.should_not be_false
     end
 
     context ".buckets" do
       it "should works" do
-        result = Qiniu.buckets
+        result = Qiniu::RS.buckets
         result.should_not be_false
         puts result.inspect
       end
@@ -47,7 +51,7 @@ module Qiniu
 
     context ".set_protected" do
       it "should works" do
-        result = Qiniu.set_protected(@bucket, 1)
+        result = Qiniu::RS.set_protected(@bucket, 1)
         result.should_not be_false
         puts result.inspect
       end
@@ -55,7 +59,7 @@ module Qiniu
 
     context ".set_separator" do
       it "should works" do
-        result = Qiniu.set_separator(@bucket, "-")
+        result = Qiniu::RS.set_separator(@bucket, "-")
         result.should_not be_false
         puts result.inspect
       end
@@ -63,7 +67,7 @@ module Qiniu
 
     context ".set_style" do
       it "should works" do
-        result = Qiniu.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
+        result = Qiniu::RS.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
         result.should_not be_false
         puts result.inspect
       end
@@ -71,23 +75,80 @@ module Qiniu
 
     context ".unset_style" do
       it "should works" do
-        result = Qiniu.unset_style(@bucket, "small.jpg")
+        result = Qiniu::RS.unset_style(@bucket, "small.jpg")
         result.should_not be_false
         puts result.inspect
       end
     end
 
+=begin
+    context ".set_watermark" do
+      it "should works" do
+        options = {
+          :text => "Powered by QiniuRS"
+        }
+        result = Qiniu::RS.set_watermark(1, options)
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".get_watermark" do
+      it "should works" do
+        result = Qiniu::RS.get_watermark(1)
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+=end
+
+    context ".put_auth" do
+      it "should works" do
+        result = Qiniu::RS.put_auth(10)
+        result.should_not be_false
+        result.should_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".upload" do
+      it "should works" do
+        put_url = Qiniu::RS.put_auth(10)
+        put_url.should_not be_false
+        put_url.should_not be_empty
+        puts put_url.inspect
+        result = Qiniu::RS.upload :url => put_url,
+                                  :file =>  __FILE__,
+                                  :bucket => @bucket,
+                                  :key => @key,
+                                  :mime_type => 'application/x-ruby',
+                                  :enable_crc32_check => true
+        result.should be_true
+      end
+    end
+
+    context ".put_file" do
+      it "should works" do
+        result = Qiniu::RS.put_file :file =>  __FILE__,
+                                    :bucket => @bucket,
+                                    :key => @key,
+                                    :mime_type => 'application/x-ruby',
+                                    :enable_crc32_check => true
+        result.should be_true
+      end
+    end
+
     context ".upload_file" do
       it "should works" do
         uptoken_opts = {:scope => @bucket, :escape => 0}
         upload_opts = {
-          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
           :file => __FILE__,
           :bucket => @bucket,
           :key => @key,
           :enable_crc32_check => true
         }
-        result = Qiniu.upload_file(upload_opts)
+        result = Qiniu::RS.upload_file(upload_opts)
         result.should_not be_false
         puts result.inspect
       end
@@ -95,24 +156,24 @@ module Qiniu
       it "should raise MissingArgsError" do
         uptoken_opts = {:scope => @bucket, :escape => 0}
         upload_opts = {
-          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
           :file => __FILE__,
           :key => @key,
           :enable_crc32_check => true
         }
-        lambda { Qiniu.upload_file(upload_opts) }.should raise_error(MissingArgsError)
+        lambda { Qiniu::RS.upload_file(upload_opts) }.should raise_error(RS::MissingArgsError)
       end
 
       it "should raise NoSuchFileError" do
         uptoken_opts = {:scope => @bucket, :escape => 0}
         upload_opts = {
-          :uptoken => Qiniu.generate_upload_token(uptoken_opts),
+          :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
           :file => 'no_this_file',
           :bucket => @bucket,
           :key => @key,
           :enable_crc32_check => true
         }
-        lambda { Qiniu.upload_file(upload_opts) }.should raise_error(NoSuchFileError)
+        lambda { Qiniu::RS.upload_file(upload_opts) }.should raise_error(RS::NoSuchFileError)
       end
     end
 
@@ -124,7 +185,7 @@ module Qiniu
         key = Digest::SHA1.hexdigest(localfile+Time.now.to_s)
         # generate the upload token
         uptoken_opts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com", :escape => 0}
-        uptoken = Qiniu.generate_upload_token(uptoken_opts)
+        uptoken = Qiniu::RS.generate_upload_token(uptoken_opts)
         # uploading
         upload_opts = {
             :uptoken => uptoken,
@@ -133,7 +194,7 @@ module Qiniu
             :key => key
         }
         #uploading
-        result1 = Qiniu.upload_file(upload_opts)
+        result1 = Qiniu::RS.upload_file(upload_opts)
         #drop the bigfile
         File.unlink(localfile) if File.exists?(localfile)
         #expect
@@ -141,11 +202,11 @@ module Qiniu
         result1.should_not be_false
         result1.should_not be_empty
         #stat
-        result2 = Qiniu.stat(@bucket, key)
+        result2 = Qiniu::RS.stat(@bucket, key)
         puts result2.inspect
         result2.should_not be_false
         #delete
-        result3 = Qiniu.delete(@bucket, key)
+        result3 = Qiniu::RS.delete(@bucket, key)
         puts result3.inspect
         result3.should_not be_false
       end
@@ -153,7 +214,7 @@ module Qiniu
 
     context ".stat" do
       it "should works" do
-        result = Qiniu.stat(@bucket, @key)
+        result = Qiniu::RS.stat(@bucket, @key)
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -162,7 +223,7 @@ module Qiniu
 
     context ".get" do
       it "should works" do
-        result = Qiniu.get(@bucket, @key, "qiniu_spec.rb", 10)
+        result = Qiniu::RS.get(@bucket, @key, "rs_spec.rb", 10)
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -171,7 +232,7 @@ module Qiniu
 
     context ".download" do
       it "should works" do
-        result = Qiniu.download(@bucket, @key, "rs_spec.rb", 10)
+        result = Qiniu::RS.download(@bucket, @key, "rs_spec.rb", 10)
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -180,7 +241,7 @@ module Qiniu
 
     context ".batch" do
       it "should works" do
-        result = Qiniu.batch("stat", @bucket, [@key])
+        result = Qiniu::RS.batch("stat", @bucket, [@key])
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -189,7 +250,7 @@ module Qiniu
 
     context ".batch_stat" do
       it "should works" do
-        result = Qiniu.batch_stat(@bucket, [@key])
+        result = Qiniu::RS.batch_stat(@bucket, [@key])
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -198,7 +259,7 @@ module Qiniu
 
     context ".batch_get" do
       it "should works" do
-        result = Qiniu.batch_get(@bucket, [@key])
+        result = Qiniu::RS.batch_get(@bucket, [@key])
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
@@ -207,84 +268,103 @@ module Qiniu
 
     context ".batch_download" do
       it "should works" do
-        result = Qiniu.batch_download(@bucket, [@key])
+        result = Qiniu::RS.batch_download(@bucket, [@key])
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
       end
     end
 
-=begin
     context ".batch_copy" do
       it "should works" do
-        result = Qiniu.batch_copy [@bucket, @key, @bucket, @key2]
+        result = Qiniu::RS.batch_copy @bucket, @key, @bucket, @key2
         result.should_not be_false
 
-        #result2 = Qiniu.stat(@bucket, @key2)
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
         #result2.should_not be_false
+
+        result = Qiniu::RS.delete @bucket, @key2
+        result.should_not be_false
       end
     end
 
     context ".batch_move" do
       it "should works" do
-        result = Qiniu.batch_move [@bucket, @key, @bucket, @key2]
+        result = Qiniu::RS.batch_move @bucket, @key, @bucket, @key2
         result.should_not be_false
 
-        #result2 = Qiniu.stat(@bucket, @key2)
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
         #result2.should_not be_false
 
-        result3 = Qiniu.batch_move [@bucket, @key2, @bucket, @key]
+        result3 = Qiniu::RS.batch_move @bucket, @key2, @bucket, @key
         result3.should_not be_false
       end
     end
-=end
 
     context ".move" do
       it "should works" do
-        result = Qiniu.move(@bucket, @key, @bucket, @key2)
+        result = Qiniu::RS.move(@bucket, @key, @bucket, @key2)
         result.should_not be_false
 
-        result2 = Qiniu.stat(@bucket, @key2)
+        result2 = Qiniu::RS.stat(@bucket, @key2)
         result2.should_not be_false
 
-        result3 = Qiniu.move(@bucket, @key2, @bucket, @key)
+        result3 = Qiniu::RS.move(@bucket, @key2, @bucket, @key)
         result3.should_not be_false
       end
     end
 
     context ".copy" do
       it "should works" do
-        result = Qiniu.copy(@bucket, @key, @bucket, @key2)
+        result = Qiniu::RS.copy(@bucket, @key, @bucket, @key2)
         result.should_not be_false
 
-        result3 = Qiniu.delete(@bucket, @key2)
-        result3.should_not be_false
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
+        #result2.should_not be_false
       end
     end
 
     context ".delete" do
       it "should works" do
-        result = Qiniu.delete(@bucket, @key)
+        result = Qiniu::RS.delete(@bucket, @key)
+        result.should_not be_false
+      end
+    end
+
+    context ".drop" do
+      it "should works" do
+        result = Qiniu::RS.drop(@bucket)
         result.should_not be_false
       end
     end
 
     context ".image_info" do
       it "should works" do
-        data = Qiniu.get(@test_image_bucket, @test_image_key)
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
         data.should_not be_false
         data.should_not be_empty
         puts data.inspect
-        result = Qiniu.image_info(data["url"])
+        result = Qiniu::RS.image_info(data["url"])
         result.should_not be_false
         result.should_not be_empty
         puts result.inspect
       end
     end
 
+    context ".image_exif" do
+      it "should works" do
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
+        data.should_not be_false
+        data.should_not be_empty
+        puts data.inspect
+        result = Qiniu::RS.image_exif(data["url"])
+        puts result.inspect
+      end
+    end
+
     context ".image_mogrify_save_as" do
       it "should works" do
-        data = Qiniu.get(@test_image_bucket, @test_image_key)
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
         data.should_not be_false
         data.should_not be_empty
         puts data.inspect
@@ -300,7 +380,7 @@ module Qiniu
           :format => "jpg",
           :auto_orient => true
         }
-        result2 = Qiniu.image_mogrify_save_as(@test_image_bucket, dest_key, src_img_url, mogrify_options)
+        result2 = Qiniu::RS.image_mogrify_save_as(@test_image_bucket, dest_key, src_img_url, mogrify_options)
         result2.should_not be_false
         result2.should_not be_empty
         puts result2.inspect
@@ -309,7 +389,7 @@ module Qiniu
 
     context ".generate_upload_token" do
       it "should works" do
-        data = Qiniu.generate_upload_token({:scope => @bucket, :expires_in => 3600, :escape => 0})
+        data = Qiniu::RS.generate_upload_token({:scope => @bucket, :expires_in => 3600, :escape => 0})
         data.should_not be_empty
         puts data.inspect
         data.split(":").length.should == 3
@@ -318,7 +398,7 @@ module Qiniu
 
     context ".generate_download_token" do
       it "should works" do
-        data = Qiniu.generate_download_token({:expires_in => 1, :pattern => 'http://*.dn.qbox.me/*'})
+        data = Qiniu::RS.generate_download_token({:expires_in => 1, :pattern => 'http://*.dn.qbox.me/*'})
         data.should_not be_empty
         puts data.inspect
         data.split(":").length.should == 3
@@ -326,4 +406,4 @@ module Qiniu
     end
 
   end
-end # module Qiniu
+end

spec/qiniu/upload_spec.rb

@@ -1,308 +0,0 @@
-# -*- encoding: utf-8 -*-
-# vim: sw=2 ts=2
-
-require 'spec_helper'
-require 'qiniu/auth'
-require 'qiniu/storage'
-require 'digest/sha1'
-
-module Qiniu
-  module Storage
-    describe Storage do
-
-      before :all do
-        @bucket = 'RubySDK-Test-Storage'
-        @bucket = make_unique_bucket(@bucket)
-
-        ### 尝试创建Bucket
-        result = Qiniu.mkbucket(@bucket)
-        puts result.inspect
-
-        @key = Digest::SHA1.hexdigest((Time.now.to_i+rand(100)).to_s)
-        @key = make_unique_key_in_bucket(@key)
-        puts "key=#{@key}"
-
-        @localfile_5m = "5M.txt"
-        File.open(@localfile_5m, "w"){|f| 5242888.times{ f.write(rand(9).to_s) }}
-        @key_5m = Digest::SHA1.hexdigest(@localfile_5m+Time.now.to_s)
-        @key_5m = make_unique_key_in_bucket(@key_5m)
-        puts "key_5m=#{@key_5m}"
-
-        @localfile_4m = "4M.txt"
-        File.open(@localfile_4m, "w"){|f| (1 << 22).times{ f.write(rand(9).to_s) }}
-        @key_4m = Digest::SHA1.hexdigest(@localfile_4m+Time.now.to_s)
-        @key_4m = make_unique_key_in_bucket(@key_4m)
-        puts "key_4m=#{@key_4m}"
-
-        @localfile_8m = "8M.txt"
-        File.open(@localfile_8m, "w"){|f| (1 << 23).times{ f.write(rand(9).to_s) }}
-        @key_8m = Digest::SHA1.hexdigest(@localfile_8m+Time.now.to_s)
-        @key_8m = make_unique_key_in_bucket(@key_8m)
-        puts "key_8m=#{@key_8m}"
-
-        @localfile_1m = "1M.txt"
-        File.open(@localfile_1m, "w"){|f| (1 << 20).times{ f.write(rand(9).to_s) }}
-        @key_1m = Digest::SHA1.hexdigest(@localfile_1m+Time.now.to_s)
-        @key_1m = make_unique_key_in_bucket(@key_1m)
-        puts "key_1m=#{@key_1m}"
-      end
-
-      after :all do
-        ### 清除本地临时文件
-        File.unlink(@localfile_5m) if File.exists?(@localfile_5m)
-        File.unlink(@localfile_4m) if File.exists?(@localfile_4m)
-        File.unlink(@localfile_8m) if File.exists?(@localfile_8m)
-        File.unlink(@localfile_1m) if File.exists?(@localfile_1m)
-
-        ### 不删除Bucket以备下次使用
-      end
-
-      ### 测试单文件直传
-      context ".upload_with_token" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-          code, data, raw_headers = Qiniu::Storage.upload_with_token(
-            uptoken,
-            __FILE__,
-            @bucket,
-            @key,
-            nil,
-            nil,
-            nil,
-            true
-          )
-          code.should == 200
-          puts data.inspect
-          puts raw_headers.inspect
-        end
-      end
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".upload_with_token_2" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :endUser => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-
-          code, data, raw_headers = Qiniu::Storage.upload_with_token_2(
-            uptoken,
-            __FILE__,
-            @key
-          )
-
-          code.should == 200
-          puts data.inspect
-          puts raw_headers.inspect
-        end
-      end # .upload_with_token_2
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".upload_with_put_policy" do
-        it "should works" do
-          pp = Qiniu::Auth::PutPolicy.new(@bucket, @key)
-          pp.end_user = "why404@gmail.com"
-          puts 'put_policy=' + pp.to_json
-
-          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
-            pp,
-            __FILE__,
-            @key + '-not-equal'
-          )
-          code.should_not == 200
-          puts data.inspect
-          puts raw_headers.inspect
-
-          code, data, raw_headers = Qiniu::Storage.upload_with_put_policy(
-            pp,
-            __FILE__,
-            @key
-          )
-
-          code.should == 200
-          puts data.inspect
-          puts raw_headers.inspect
-        end
-      end # .upload_with_put_policy
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      ### 测试断点续上传
-      context ".resumable_upload_with_token" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
-            uptoken,
-            @localfile_5m,
-            @bucket,
-            @key_5m
-          )
-          (code/100).should == 2
-          puts data.inspect
-          puts raw_headers.inspect
-          puts "key_5m=#{@key_5m}"
-        end
-      end
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key_5m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key_5m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".resumable_upload_with_token2" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
-            uptoken,
-            @localfile_4m,
-            @bucket,
-            @key_4m
-          )
-          (code/100).should == 2
-          puts data.inspect
-          puts raw_headers.inspect
-          puts "key_4m=#{@key_4m}"
-        end
-      end
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key_4m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key_4m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".resumable_upload_with_token3" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
-            uptoken,
-            @localfile_8m,
-            @bucket,
-            @key_8m
-          )
-          (code/100).should == 2
-          puts data.inspect
-          puts raw_headers.inspect
-          puts "key_8m=#{@key_8m}"
-        end
-      end
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key_8m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key_8m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".resumable_upload_with_token4" do
-        it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "why404@gmail.com"}
-          uptoken = Qiniu.generate_upload_token(upopts)
-          code, data, raw_headers = Qiniu::Storage.resumable_upload_with_token(
-            uptoken,
-            @localfile_1m,
-            @bucket,
-            @key_1m
-          )
-          (code/100).should == 2
-          puts data.inspect
-          puts raw_headers.inspect
-          puts "key_1m=#{@key_1m}"
-        end
-      end
-
-      context ".stat" do
-        it "should exists" do
-          code, data = Qiniu::Storage.stat(@bucket, @key_1m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-      context ".delete" do
-        it "should works" do
-          code, data = Qiniu::Storage.delete(@bucket, @key_1m)
-          puts data.inspect
-          code.should == 200
-        end
-      end
-
-    end
-  end # module Storage
-end # module Qiniu

spec/qiniu/version_spec.rb

@@ -1,10 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-require 'qiniu/version'
-
-describe Qiniu::Version do
-  it "should has a VERSION" do
-    Qiniu::Version.to_s.should =~ /^\d+\.\d+\.\d+?$/
-  end
-end

spec/spec_helper.rb

@@ -1,19 +1,11 @@
 # -*- encoding: utf-8 -*-
 
 require 'bundler/setup'
-require 'qiniu'
+require 'qiniu/rs'
 require 'rspec'
 
 RSpec.configure do |config|
   config.before :all do
-    Qiniu.establish_connection! :access_key => ENV["QINIU_ACCESS_KEY"], :secret_key => ENV["QINIU_SECRET_KEY"]
+    Qiniu::RS.establish_connection! :access_key => ENV["QINIU_ACCESS_KEY"], :secret_key => ENV["QINIU_SECRET_KEY"]
   end
 end
-
-def make_unique_bucket (bucket)
-    bucket + "-" + ENV["QINIU_ACCESS_KEY"][0, 8]
-end # make_unique_bucket
-
-def make_unique_key_in_bucket (key)
-    "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}-" + key
-end # make_unique_key_in_bucket