Merge pull request #54 from qiniu/release/v3.4.3

callbackBody + returnUrl supported

.travis.yml

@@ -7,6 +7,8 @@ rvm:
   - jruby-19mode
   - rbx-18mode
   - rbx-19mode
-  - ruby-head
   - jruby-head
   - ree
+before_script:
+  - export QINIU_ACCESS_KEY=LGRqJsjX7LAvtdtX6hhyxs861lS57HwnOQmJsOuX
+  - export QINIU_SECRET_KEY=g_OxhuN5iJ1O7BoA6YdXyF6zSszk34UZFKDfdIIW

CHANGELOG.md

@@ -0,0 +1,70 @@
+## CHANGE LOG
+
+### v3.4.2
+
+- `Qiniu::RS.generate_upload_token()` 方法新增 `:return_body` 选项。
+
+该选项（`:return_body`）可设置文件上传成功后，执行七牛云存储规定的回调API，并以 JSON 响应格式返回其执行结果。参考 [uploadToken 之 returnBody 说明](http://docs.qiniutek.com/v3/api/io/#uploadToken-returnBody)。
+
+### v3.4.1
+
+增加为上传文件进行预转的选项，参见 [uploadToken 之 asyncOps 说明](http://docs.qiniutek.com/v3/api/io/#uploadToken-asyncOps)
+
+- `Qiniu::RS.generate_upload_token()` 方法新增 `:async_options` 选项用于进行预转操作。
+
+### v3.4.0
+
+增加文件复制/移动方法，包括批量复制/移动文件
+
+- `Qiniu::RS.copy(source_bucket, source_key, target_bucket, target_key)`
+- `Qiniu::RS.move(source_bucket, source_key, target_bucket, target_key)`
+- `Qiniu::RS.batch_copy [source_bucket, source_key, target_bucket, target_key], ...`
+- `Qiniu::RS.batch_move [source_bucket, source_key, target_bucket, target_key], ...`
+
+### v3.3.1
+
+确保单元测试里边用到的测试 Bucket 全局唯一
+
+使得10多种不通的 Ruby 宿主环境能隔离互不影响地执行单元/集成测试
+
+Ruby 宿主环境如下
+
+1.8.7, 1.9.2, 1.9.3, jruby-18mode, jruby-19mode, rbx-18mode, rbx-19mode, ruby-head, jruby-head, ree
+
+详见 <https://travis-ci.org/qiniu/ruby-sdk>
+
+### v3.3.0
+
+私有资源下载新版实现，添加 Qiniu::RS.generate_download_token() 方法。参考 [downloadToken](http://docs.qiniutek.com/v3/api/io/#get)
+
+详见 [Ruby SDK 使用文档之私有资源下载](http://docs.qiniutek.com/v3/sdk/ruby/#download-private-files)
+
+### v3.2.2
+
+fixed E701 error
+
+断点续上传根据 mkblk 返回的 host 字段进行 bput 和 mkfile ，规避由于DNS智能解析造成的分布式并行块上传会出现上下文不连贯导致的 E701 问题。
+
+### v3.2.1
+
+allow images uploaded auto-orient.
+
+允许图片上传成功后自动旋转。
+
+参考：
+
+1. [[API] multipart/form-data 上传文件之 action 字段详解](http://docs.qiniutek.com/v3/api/io/#upload-action)
+2. [[SDK] Qiniu::RS.upload_file() 方法中的参数增加了 :rotate 选项](http://docs.qiniutek.com/v3/sdk/ruby/#upload-server-side)
+
+### v3.2.0
+
+2012-11-06
+
+allow files uploaded auto callback some APIs (like imageInfo, exif, etc…), and add those APIs callback results as part of the custom data for POST biz-server.
+
+允许上传文件(图片)成功后执行回调指定的 API (比如 imageInfo, exif 接口等)，并将指定API的回调结果一并 POST 发送给客户方的业务服务器。
+
+参考：
+
+1. [[API] 生成上传授权凭证 uploadToken 之 escape 参数详解](http://docs.qiniutek.com/v3/api/io/#escape-expression)
+2. [[SDK] Qiniu::RS.generate_upload_token() 方法中的参数增加了 :escape 选项](http://docs.qiniutek.com/v3/sdk/ruby/#generate-upload-token)

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qiniu-rs (3.0.6)
+    qiniu-rs (3.4.2)
       json (~> 1.7)
       mime-types (~> 1.19)
       rest-client (~> 1.6)
@@ -12,19 +12,19 @@ GEM
   specs:
     diff-lcs (1.1.3)
     fakeweb (1.3.0)
-    json (1.7.5)
-    mime-types (1.19)
-    rake (0.9.2.2)
+    json (1.7.6)
+    mime-types (1.20.1)
+    rake (10.0.3)
     rest-client (1.6.7)
       mime-types (>= 1.16)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.2)
+    rspec-mocks (2.12.2)
     ruby-hmac (0.4.0)
 
 PLATFORMS
@@ -33,5 +33,5 @@ PLATFORMS
 DEPENDENCIES
   fakeweb (~> 1.3)
   qiniu-rs!
-  rake (~> 0.9)
-  rspec (~> 2.11)
+  rake (>= 0.9)
+  rspec (>= 2.11)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 why404
+Copyright (c) 2012-2013 qiniutek.com
 
 MIT License
 

README.md

@@ -1,4 +1,4 @@
-# Qiniu Resource (Cloud) Storage SDK for Ruby - [![Build Status](https://secure.travis-ci.org/why404/qiniu-rs-for-ruby.png?branch=master)](http://travis-ci.org/why404/qiniu-rs-for-ruby) [![Dependency Status](https://gemnasium.com/why404/qiniu-rs-for-ruby.png)](https://gemnasium.com/why404/qiniu-rs-for-ruby)
+# Qiniu Resource (Cloud) Storage SDK for Ruby - [![Build Status](https://api.travis-ci.org/qiniu/ruby-sdk.png?branch=master)](https://travis-ci.org/qiniu/ruby-sdk) [![Dependency Status](https://gemnasium.com/why404/qiniu-rs-for-ruby.png)](https://gemnasium.com/why404/qiniu-rs-for-ruby)
 
 # 关于
 
@@ -32,7 +32,7 @@
 
 ## 许可证
 
-Copyright (c) 2012 qiniutek.com
+Copyright (c) 2012-2013 qiniutek.com
 
 基于 MIT 协议发布:
 

lib/qiniu/rs.rb

@@ -1,15 +1,15 @@
 # -*- encoding: utf-8 -*-
 
-require 'qiniu/rs/version'
-
 module Qiniu
   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'
@@ -17,6 +17,8 @@ module Qiniu
     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
 
@@ -61,6 +63,7 @@ module Qiniu
         code == StatusOK
       end
 
+=begin
       def set_watermark(customer_id, options = {})
         code, data = EU.set_watermark(customer_id, options)
         code == StatusOK
@@ -70,6 +73,7 @@ module Qiniu
         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)
@@ -99,15 +103,37 @@ module Qiniu
       end
 
       def upload_file opts = {}
-        code, data = IO.upload_with_token(opts[:uptoken],
-                                          opts[:file],
-                                          opts[:bucket],
-                                          opts[:key],
-                                          opts[:mime_type],
-                                          opts[:note],
-                                          opts[:callback_params],
-                                          opts[:enable_crc32_check])
-        code == StatusOK ? data : false
+        uncontained_opts = [:uptoken, :file, :bucket, :key] - opts.keys
+        raise MissingArgsError, uncontained_opts unless uncontained_opts.empty?
+
+        source_file = opts[:file]
+        raise NoSuchFileError, source_file unless File.exist?(source_file)
+
+        opts[:enable_resumable_upload] = true unless opts.has_key?(:enable_resumable_upload)
+
+        if opts[:enable_resumable_upload] && File::size(source_file) > Config.settings[:block_size]
+          code, data = UP.upload_with_token(opts[:uptoken],
+                                            opts[:file],
+                                            opts[:bucket],
+                                            opts[:key],
+                                            opts[:mime_type],
+                                            opts[:note],
+                                            opts[:customer],
+                                            opts[:callback_params],
+                                            opts[:rotate])
+        else
+          code, data = IO.upload_with_token(opts[:uptoken],
+                                            opts[:file],
+                                            opts[:bucket],
+                                            opts[:key],
+                                            opts[:mime_type],
+                                            opts[:note],
+                                            opts[:callback_params],
+                                            opts[:enable_crc32_check],
+                                            opts[:rotate])
+        end
+        raise UploadFailedError.new(code, data) if code != StatusOK
+        return data
       end
 
       def stat(bucket, key)
@@ -125,6 +151,16 @@ module Qiniu
         code == StatusOK ? data["url"] : false
       end
 
+      def 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 = RS.move(source_bucket, source_key, target_bucket, target_key)
+        code == StatusOK
+      end
+
       def delete(bucket, key)
         code, data = RS.delete(bucket, key)
         code == StatusOK
@@ -145,6 +181,16 @@ module Qiniu
         code == StatusOK ? data : false
       end
 
+      def batch_copy(*args)
+        code, data = RS.batch_copy(args)
+        code == StatusOK
+      end
+
+      def batch_move(*args)
+        code, data = RS.batch_move(args)
+        code == StatusOK
+      end
+
       def batch_download(bucket, keys)
         code, data = RS.batch_get(bucket, keys)
         return false unless code == StatusOK
@@ -205,6 +251,18 @@ module Qiniu
         #token_obj.callback_url = opts[:callback_url]
         #token_obj.callback_body_type = opts[:callback_body_type]
         #token_obj.customer = opts[:customer]
+        #token_obj.escape = opts[:escape]
+        #token_obj.async_options = opts[:async_options]
+        #token_obj.return_body = opts[:return_body]
+        token_obj.generate_token
+      end
+
+      def generate_download_token(opts = {})
+        token_obj = DownloadToken.new(opts)
+        token_obj.access_key = Config.settings[:access_key]
+        token_obj.secret_key = Config.settings[:secret_key]
+        #token_obj.expires_in = opts[:expires_in]
+        #token_obj.pattern = opts[:pattern]
         token_obj.generate_token
       end
 

lib/qiniu/rs/abstract.rb

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

lib/qiniu/rs/auth.rb

@@ -18,7 +18,7 @@ module Qiniu
             :password   => password
           }
           code, data = http_request Config.settings[:auth_url], post_data
-          reset_token(data["access_token"], data["refresh_token"]) if code == 200
+          reset_token(data["access_token"], data["refresh_token"]) if Utils.is_response_ok?(code)
           [code, data]
         end
 
@@ -29,7 +29,7 @@ module Qiniu
             :refresh_token => refresh_token
           }
           code, data = http_request Config.settings[:auth_url], post_data
-          reset_token(data["access_token"], data["refresh_token"]) if code == 200
+          reset_token(data["access_token"], data["refresh_token"]) if Utils.is_response_ok?(code)
           [code, data]
         end
 
@@ -48,7 +48,7 @@ module Qiniu
               raise MissingUsernameOrPassword if (@username.nil? || @password.nil?)
               code, data = exchange_by_password!(@username, @password)
             end
-            if code == 200
+            if Utils.is_response_ok?(code)
               retry_times += 1
               if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
                 return call_with_logged_in(url, data, retry_times)

lib/qiniu/rs/config.rb

@@ -8,7 +8,7 @@
 # Qbox::Config.load "path/to/your_project/config/qiniu.yml"
 #
 
-require "qiniu/rs/version"
+require 'tmpdir'
 
 module Qiniu
   module RS
@@ -16,11 +16,11 @@ module Qiniu
       class << self
 
         DEFAULT_OPTIONS = {
-          :user_agent      => 'Qiniu-RS-Ruby-SDK-' + VERSION + '()',
+          :user_agent      => 'Qiniu-RS-Ruby-SDK-' + Version.to_s + '()',
           :method          => :post,
           :content_type    => 'application/x-www-form-urlencoded',
           :auth_url        => "https://acc.qbox.me/oauth2/token",
-          :rs_host         => "http://rs.qbox.me:10100",
+          :rs_host         => "http://rs.qbox.me",
           :io_host         => "http://iovip.qbox.me",
           :up_host         => "http://up.qbox.me",
           :pub_host        => "http://pu.qbox.me:10200",
@@ -30,10 +30,14 @@ module Qiniu
           :access_key      => "",
           :secret_key      => "",
           :auto_reconnect  => true,
-          :max_retry_times => 5
+          :max_retry_times => 3,
+          :block_size      => 1024*1024*4,
+          :chunk_size      => 1024*256,
+          :enable_debug    => true,
+          :tmpdir          => Dir.tmpdir + File::SEPARATOR + 'Qiniu-RS-Ruby-SDK'
         }
 
-        REQUIRED_OPTION_KEYS = [:client_id, :client_secret, :auth_url, :rs_host, :io_host]
+        REQUIRED_OPTION_KEYS = [:access_key, :secret_key]
 
         attr_reader :settings, :default_params
 

lib/qiniu/rs/exceptions.rb

@@ -4,9 +4,6 @@ module Qiniu
   module RS
 
     class Exception < RuntimeError
-      def to_s
-        inspect
-      end
     end
 
     class ResponseError < Exception
@@ -32,7 +29,7 @@ module Qiniu
 
     class RequestFailed < ResponseError
       def message
-        "HTTP status code #{http_code}"
+        "HTTP status code: #{http_code}. Response body: #{http_body}"
       end
 
       def to_s
@@ -40,6 +37,43 @@ module Qiniu
       end
     end
 
+    class UploadFailedError < Exception
+      def initialize(status_code, response_data)
+        data_string = response_data.map { |key, value| %Q(:#{key.to_s} => #{value.to_s}) }
+        msg = %Q(Uploading Failed. HTTP Status Code: #{status_code}. HTTP response body: #{data_string.join(', ')}.)
+        super(msg)
+      end
+    end
+
+    class FileSeekReadError < Exception
+      def initialize(fpath, block_index, seek_pos, read_length, result_length)
+        msg =  "Reading file: #{fpath}, "
+        msg += "at block index: #{block_index}. "
+        msg += "Expected seek_pos:#{seek_pos} and read_length:#{read_length}, "
+        msg += "but got result_length: #{result_length}."
+        super(msg)
+      end
+    end
+
+    class BlockSizeNotMathchError < Exception
+      def initialize(fpath, block_index, offset, restsize, block_size)
+        msg  = "Reading file: #{fpath}, "
+        msg += "at block index: #{block_index}. "
+        msg += "Expected offset: #{offset}, restsize: #{restsize} and block_size: #{block_size}, "
+        msg += "but got offset+restsize=#{offset+restsize}."
+        super(msg)
+      end
+    end
+
+    class BlockCountNotMathchError < Exception
+      def initialize(fpath, block_count, checksum_count, progress_count)
+        msg  = "Reading file: #{fpath}, "
+        msg += "Expected block_count, checksum_count, progress_count is: #{block_count}, "
+        msg += "but got checksum_count: #{checksum_count}, progress_count: #{progress_count}."
+        super(msg)
+      end
+    end
+
     class MissingArgsError < Exception
       def initialize(missing_keys)
         key_list = missing_keys.map {|key| key.to_s}.join(' and the ')

lib/qiniu/rs/io.rb

@@ -34,8 +34,8 @@ module Qiniu
           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)
-          action_params = _generate_action_params(local_file, bucket, key, mime_type, custom_meta, enable_crc32_check)
+        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'
@@ -43,7 +43,7 @@ module Qiniu
         end
 
         private
-        def _generate_action_params(local_file, bucket, key = nil, mime_type = nil, custom_meta = nil, enable_crc32_check = false)
+        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
@@ -54,6 +54,7 @@ module Qiniu
           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
 

lib/qiniu/rs/rs.rb

@@ -26,6 +26,16 @@ module Qiniu
           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)
+          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)
+          Auth.request Config.settings[:rs_host] + uri
+        end
+
         def delete(bucket, key)
           Auth.request Config.settings[:rs_host] + '/delete/' + encode_entry_uri(bucket, key)
         end
@@ -61,6 +71,14 @@ module Qiniu
           batch("stat", bucket, keys)
         end
 
+        def batch_copy(*args)
+          _batch_cp_or_mv('copy', args)
+        end
+
+        def batch_move(*args)
+          _batch_cp_or_mv('move', args)
+        end
+
         def batch_delete(bucket, keys)
           batch("delete", bucket, keys)
         end
@@ -77,6 +95,22 @@ module Qiniu
           save_as(bucket, key, source_image_url, mogrify_params_string)
         end
 
+        private
+
+        def _generate_cp_or_mv_opstr(command, source_bucket, source_key, target_bucket, target_key)
+          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
+
+        def _batch_cp_or_mv(command, *op_args)
+          execs = []
+          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
+          Auth.request Config.settings[:rs_host] + "/batch?" + execs.join("&")
+        end
+
       end
     end
   end

lib/qiniu/rs/up.rb

@@ -0,0 +1,324 @@
+# -*- encoding: utf-8 -*-
+
+require 'zlib'
+require 'yaml'
+require 'tmpdir'
+require 'fileutils'
+require 'mime/types'
+require 'digest/sha1'
+require 'qiniu/rs/abstract'
+require 'qiniu/rs/exceptions'
+require 'qiniu/rs/io'
+
+module Qiniu
+  module RS
+    module UP
+
+      PROGRESS_TMP_FILE = 'progresses'
+      CHECKSUM_TMP_FILE = 'ctxes'
+
+      module AbstractClass
+        class ChunkProgressNotifier
+          include Qiniu::RS::Abstract
+          abstract_methods :notify
+          # def notify(block_index, block_put_progress); end
+        end
+
+        class BlockProgressNotifier
+          include Qiniu::RS::Abstract
+          abstract_methods :notify
+          # def notify(block_index, checksum); end
+        end
+      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 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 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 upload_with_token(uptoken,
+                              local_file,
+                              bucket,
+                              key = nil,
+                              mime_type = nil,
+                              custom_meta = nil,
+                              customer = nil,
+                              callback_params = nil,
+                              rotate = nil)
+          begin
+            ifile = File.open(local_file, 'rb')
+            fh = FileData.new(ifile)
+            fsize = fh.data_size
+            key = Digest::SHA1.hexdigest(local_file + fh.mtime.to_s) if key.nil?
+            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
+            code, data = _resumable_upload(uptoken, fh, fsize, bucket, key, mime_type, custom_meta, customer, callback_params, rotate)
+            [code, data]
+          ensure
+            ifile.close unless ifile.nil?
+          end
+        end
+
+        private
+
+        class FileData
+            attr_accessor :fh
+            def initialize(fh)
+                @fh = fh
+            end
+            def data_size
+                @fh.stat.size
+            end
+            def get_data(offset, length)
+                @fh.seek(offset)
+                @fh.read(length)
+            end
+            def path
+                @fh.path
+            end
+            def mtime
+                @fh.mtime
+            end
+            #delegate :path, :mtime, :to => :fh
+        end
+
+        def _new_block_put_progress_data
+          {:ctx => nil, :offset => 0, :restsize => nil, :status_code => nil, :host => nil}
+        end
+
+        def _call_binary_with_token(uptoken, url, data, content_type = nil, retry_times = 0)
+          options = {
+              :method => :post,
+              :content_type => 'application/octet-stream',
+              :upload_signature_token => uptoken
+          }
+          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
+          [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
+
+        def _putblock(uphost, uptoken, ctx, offset, body)
+            url = uphost + "/bput/#{ctx}/#{offset}"
+            _call_binary_with_token(uptoken, url, body)
+        end
+
+        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
+                progress[:restsize] = block_size
+                # choose the smaller one
+                body_length = [block_size, chunk_size].min
+                for i in 1..retry_times
+                    seek_pos = block_index*Config.settings[:block_size]
+                    body = fh.get_data(seek_pos, body_length)
+                    result_length = body.length
+                    if result_length != body_length
+                        raise FileSeekReadError.new(fpath, block_index, seek_pos, body_length, result_length)
+                    end
+                    code, data = _mkblock(uptoken, block_size, body)
+                    body_crc32 = Zlib.crc32(body)
+                    if Utils.is_response_ok?(code) && data["crc32"] == body_crc32
+                        progress[:ctx] = data["ctx"]
+                        progress[:offset] = body_length
+                        progress[:restsize] = block_size - body_length
+                        progress[:status_code] = code
+                        progress[:host] = data["host"]
+                        if !notifier.nil? && notifier.respond_to?("notify")
+                            notifier.notify(block_index, progress)
+                        end
+                        break
+                    elsif i == retry_times && data["crc32"] != body_crc32
+                        Log.logger.error %Q(Uploading block error. Expected crc32: #{body_crc32}, but got: #{data["crc32"]})
+                    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
+                body_length = [progress[:restsize], chunk_size].min
+                for i in 1..retry_times
+                    seek_pos = block_index*Config.settings[:block_size] + progress[:offset]
+                    body = fh.get_data(seek_pos, body_length)
+                    result_length = body.length
+                    if result_length != body_length
+                        raise FileSeekReadError.new(fpath, block_index, seek_pos, body_length, result_length)
+                    end
+                    code, data = _putblock(progress[:host], uptoken, progress[:ctx], progress[:offset], body)
+                    body_crc32 = Zlib.crc32(body)
+                    if Utils.is_response_ok?(code) && data["crc32"] == body_crc32
+                        progress[:ctx] = data["ctx"]
+                        progress[:offset] += body_length
+                        progress[:restsize] -= body_length
+                        progress[:status_code] = code
+                        progress[:host] = data["host"]
+                        if !notifier.nil? && notifier.respond_to?("notify")
+                            notifier.notify(block_index, progress)
+                        end
+                        break
+                    elsif i == retry_times && data["crc32"] != body_crc32
+                        Log.logger.error %Q(Uploading block error. Expected crc32: #{body_crc32}, but got: #{data["crc32"]})
+                    end
+                end
+            end
+            # return
+            return [code, data]
+        end
+
+        def _block_count(fsize)
+            ((fsize + Config.settings[:block_size] - 1) / Config.settings[:block_size]).to_i
+        end
+
+        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)
+            checksum_count = checksums.length
+            progress_count = progresses.length
+            if checksum_count != block_count || progress_count != block_count
+                raise BlockCountNotMathchError.new(fh.path, block_count, checksum_count, progress_count)
+            end
+            0.upto(block_count-1).each do |block_index|
+                if checksums[block_index].nil? || checksums[block_index].empty?
+                    block_size = Config.settings[:block_size]
+                    if block_index == block_count - 1
+                        block_size = fsize - block_index*Config.settings[:block_size]
+                    end
+                    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)
+                    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")
+                            block_notifier.notify(block_index, checksums[block_index])
+                        end
+                    end
+                end
+            end
+            return [code, data]
+        end
+
+        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 = 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
+          #body = ''
+          #checksums.each do |checksum|
+          #    body += Utils.urlsafe_base64_decode(checksum)
+          #end
+          body = checksums.join(',')
+          _call_binary_with_token(uptoken, url, body, 'text/plain')
+        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(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 = _mkfile(uphost, uptoken, entry_uri, fsize, checksums, mime_type, custom_meta, customer, callback_params, rotate)
+          end
+          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
+
+      end
+
+    end
+  end
+end

lib/qiniu/rs/utils.rb

@@ -32,6 +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]
@@ -42,8 +56,8 @@ module Qiniu
         auth_token = nil
         if !options[:qbox_signature_token].nil? && !options[:qbox_signature_token].empty?
           auth_token = 'QBox ' + options[:qbox_signature_token]
-        #elsif !options[:upload_signature_token].nil? && !options[:upload_signature_token].empty?
-        #  auth_token = 'UpToken ' + options[:upload_signature_token]
+        elsif !options[:upload_signature_token].nil? && !options[:upload_signature_token].empty?
+          auth_token = 'UpToken ' + options[:upload_signature_token]
         elsif options[:access_token]
           auth_token = 'Bearer ' + options[:access_token]
         end
@@ -56,8 +70,8 @@ module Qiniu
           response = RestClient.post(url, data, header_options)
         end
         code = response.respond_to?(:code) ? response.code.to_i : 0
-        if code != 200
-          raise RequestFailed.new(response)
+        unless is_response_ok?(code)
+          raise RequestFailed.new("Request Failed", response)
         else
           data = {}
           body = response.respond_to?(:body) ? response.body : {}

lib/qiniu/rs/version.rb

@@ -2,6 +2,18 @@
 
 module Qiniu
   module RS
-    VERSION = "3.0.6"
+    module Version
+      MAJOR = 3
+      MINOR = 4
+      PATCH = 2
+      # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
+      #
+      # Example
+      #
+      #   Version.to_s # '1.0.2'
+      def self.to_s
+        [MAJOR, MINOR, PATCH].join('.')
+      end
+    end
   end
 end

lib/qiniu/tokens/download_token.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/rs/utils'
+
+module Qiniu
+  module RS
+      class DownloadToken < AccessToken
+
+        include Utils
+
+        attr_accessor :pattern, :expires_in
+
+        def initialize(opts = {})
+          @pattern = opts[:pattern] || "*"
+          @expires_in = opts[:expires_in] || 3600
+        end
+
+        def generate_signature
+          params = {"S" => @pattern, "E" => Time.now.to_i + @expires_in}
+          Utils.urlsafe_base64_encode(params.to_json)
+        end
+
+        def generate_token
+          signature = generate_signature
+          encoded_digest = generate_encoded_digest(signature)
+          %Q(#{@access_key}:#{encoded_digest}:#{signature})
+        end
+
+      end
+  end
+end

lib/qiniu/tokens/qbox_token.rb

@@ -8,6 +8,8 @@ module Qiniu
   module RS
       class QboxToken < AccessToken
 
+        include Utils
+
         attr_accessor :url, :params
 
         def initialize(opts = {})
@@ -20,16 +22,16 @@ module Qiniu
           signature = uri.path
           query_string = uri.query
           signature += '?' + query_string if !query_string.nil? && !query_string.empty?
-          signature += "\n";
+          signature += "\n"
           if @params.is_a?(Hash)
-            total_param = @params.map { |key, value| %Q(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub('+', '%20')}) }
-            signature += total_param.join("&")
+              params_string = Utils.generate_query_string(@params)
+              signature += params_string
           end
           signature
         end
 
         def generate_token
-          encoded_digest = generate_encoded_digest(signature)
+          encoded_digest = generate_encoded_digest(generate_signature)
           %Q(#{@access_key}:#{encoded_digest})
         end
 

lib/qiniu/tokens/upload_token.rb

@@ -10,22 +10,32 @@ module Qiniu
 
         include Utils
 
-        attr_accessor :scope, :expires_in, :callback_url, :callback_body_type, :customer
+        attr_accessor :scope, :expires_in, :callback_url, :callback_body, :callback_body_type, :customer, :escape, :async_options, :return_body, :return_url
 
         def initialize(opts = {})
           @scope = opts[:scope]
           @expires_in = opts[:expires_in] || 3600
           @callback_url = opts[:callback_url]
+          @callback_body = opts[:callback_body]
           @callback_body_type = opts[:callback_body_type]
           @customer = opts[:customer]
+          @escape = opts[:escape]
+          @async_options = opts[:async_options]
+          @return_body = opts[:return_body]
+          @return_url = opts[:return_url]
         end
 
         def generate_signature
           params = {:scope => @scope, :deadline => Time.now.to_i + @expires_in}
           params[:callbackUrl] = @callback_url if !@callback_url.nil? && !@callback_url.empty?
+          params[:callbackBody] = @callback_body if !@callback_body.nil? && !@callback_body.empty?
           params[:callbackBodyType] = @callback_body_type if !@callback_body_type.nil? && !@callback_body_type.empty?
           params[:customer] = @customer if !@customer.nil? && !@customer.empty?
-          urlsafe_base64_encode(params.to_json)
+          params[:escape] = 1 if @escape == 1 || @escape == true
+          params[:asyncOps] = @async_options if !@async_options.nil? && !@async_options.empty?
+          params[:returnBody] = @return_body if !@return_body.nil? && !@return_body.empty?
+          params[:returnUrl] = @return_url if !@return_url.nil? && !@return_url.empty?
+          Utils.urlsafe_base64_encode(params.to_json)
         end
 
         def generate_token

qiniu-rs.gemspec

@@ -14,11 +14,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "qiniu-rs"
   gem.require_paths = ["lib"]
-  gem.version       = Qiniu::RS::VERSION
+  gem.version       = Qiniu::RS::Version.to_s
 
   # specify any dependencies here; for example:
-  gem.add_development_dependency "rake", "~> 0.9"
-  gem.add_development_dependency "rspec", "~> 2.11"
+  gem.add_development_dependency "rake", ">= 0.9"
+  gem.add_development_dependency "rspec", ">= 2.11"
   gem.add_development_dependency "fakeweb", "~> 1.3"
   gem.add_runtime_dependency "json", "~> 1.7"
   gem.add_runtime_dependency "rest-client", "~> 1.6"

spec/qiniu/rs/abstract_spec.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs/abstract'
+
+describe Qiniu::RS::Abstract do
+  before(:each) do
+    @klass = Class.new do
+      include Qiniu::RS::Abstract
+
+      abstract_methods :foo, :bar
+    end
+  end
+
+  it "raises NotImplementedError" do
+    proc {
+      @klass.new.foo
+    }.should raise_error(NotImplementedError)
+  end
+
+  it "can be overridden" do
+    subclass = Class.new(@klass) do
+      def foo
+        :overridden
+      end
+    end
+
+    subclass.new.foo.should == :overridden
+  end
+end

spec/qiniu/rs/eu_spec.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'spec_helper'
-require 'qiniu/rs/io'
+require 'qiniu/rs'
 require 'qiniu/rs/pub'
 require 'qiniu/rs/eu'
 
@@ -10,16 +10,19 @@ module Qiniu
     describe EU do
 
       before :all do
-        @customer_id = "awhy.xu@gmail.com"
-        @bucket = "wm_test_bucket"
+        @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)
 
-        code, data = Qiniu::RS::IO.upload_with_token(uptoken, local_file, @bucket, @key, nil, nil, nil, true)
-        code.should == 200
+        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, "-")
@@ -31,11 +34,13 @@ module Qiniu
         puts data3.inspect
       end
 
-      #after :all do
-      #  result = Qiniu::RS.drop(@bucket)
-      #  result.should_not be_false
-      #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 = {
@@ -54,6 +59,7 @@ module Qiniu
           puts data.inspect
         end
       end
+=end
 
     end
   end

spec/qiniu/rs/image_spec.rb

@@ -10,35 +10,31 @@ module Qiniu
     describe Image do
 
       before :all do
-=begin
-        code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
-        code.should == 200
-        data.should be_an_instance_of(Hash)
-        data["access_token"].should_not be_empty
-        data["refresh_token"].should_not be_empty
-        data["refresh_token"].should_not be_empty
-        puts data.inspect
-=end
 
-        @bucket = "test_images_12345"
+        @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__)
 
-        result = Qiniu::RS.drop(@bucket)
-        result.should_not be_false
-        puts result.inspect
-
-        put_url = Qiniu::RS.put_auth(10)
-        put_url.should_not be_false
-        put_url.should_not be_empty
-        result = Qiniu::RS.upload :url => put_url,
-                                  :file => local_file,
-                                  :bucket => @bucket,
-                                  :key => @key,
-                                  :enable_crc32_check => true
-        result.should be_true
+        upopts = {
+            :scope => @bucket,
+            :expires_in => 3600,
+            :customer => "why404@gmail.com",
+            :async_options => "imageView/1/w/120/h/120",
+            :return_body => '{"size":$(fsize), "hash":$(etag), "width":$(imageInfo.width), "height":$(imageInfo.height)}'
+        }
+        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
+        data["hash"].should_not be_empty
+        data["width"].should_not be_zero
+        data["height"].should_not be_zero
 
         result = Qiniu::RS.get(@bucket, @key)
         result["url"].should_not be_empty
@@ -56,6 +52,12 @@ module Qiniu
         }
       end
 
+      after :all do
+        result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
+        result.should_not be_false
+      end
+
       context ".info" do
         it "should works" do
           code, data = Qiniu::RS::Image.info(@source_image_url)

spec/qiniu/rs/io_spec.rb

@@ -1,4 +1,4 @@
-# Utils.-*- encoding: utf-8 -*-
+# -*- encoding: utf-8 -*-
 
 require 'spec_helper'
 require 'qiniu/rs/auth'
@@ -10,17 +10,18 @@ module Qiniu
     describe IO do
 
       before :all do
-=begin
-        code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
-        code.should == 200
-        data.should be_an_instance_of(Hash)
-        data["access_token"].should_not be_empty
-        data["refresh_token"].should_not be_empty
-        data["refresh_token"].should_not be_empty
-        puts data.inspect
-=end
-        @bucket = "test"
-        @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
+        @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
@@ -46,7 +47,7 @@ module Qiniu
 
       context ".upload_with_token" do
         it "should works" do
-          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "awhy.xu@gmail.com"}
+          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

spec/qiniu/rs/pub_spec.rb

@@ -10,24 +10,15 @@ module Qiniu
     describe Pub do
 
       before :all do
-        @bucket = "test123"
-        code, data = Qiniu::RS::RS.mkbucket(@bucket)
-        code.should == 200
-        puts data.inspect
+        @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
+        result = Qiniu::RS.mkbucket(@bucket)
+        puts result.inspect
+        result.should_not be_false
       end
 
-=begin
-      context ".mkbucket" do
-        it "should works" do
-          code, data = Qiniu::RS::RS.mkbucket(@bucket)
-          code.should == 200
-          puts data.inspect
-        end
-      end
-=end
-
       after :all do
         result = Qiniu::RS.drop(@bucket)
+        puts result.inspect
         result.should_not be_false
       end
 

spec/qiniu/rs/rs_spec.rb

@@ -11,28 +11,34 @@ module Qiniu
     describe RS do
 
       before :all do
-
-        @bucket = "test_bucket_1234"
-        @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
-        @domain = 'iovip.qbox.me/test'
+        @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
-        puts data.inspect
       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
-          puts data.inspect
           @put_url = data["url"]
 
           code2, data2 = Qiniu::RS::IO.upload_file(@put_url, __FILE__, @bucket, @key)
-          code2.should == 200
           puts data2.inspect
+          code2.should == 200
         end
       end
 
@@ -84,6 +90,35 @@ module Qiniu
         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
+        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
+
+=begin
       context ".publish" do
         it "should works" do
           code, data = Qiniu::RS::RS.publish(@domain, @bucket)
@@ -99,6 +134,35 @@ module Qiniu
           puts data.inspect
         end
       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

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/version_spec.rb

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

spec/qiniu/rs_spec.rb

@@ -1,21 +1,47 @@
 # -*- encoding: utf-8 -*-
 
+require 'digest/sha1'
 require 'spec_helper'
 require 'qiniu/rs'
+require 'qiniu/rs/exceptions'
 
 module Qiniu
   describe RS do
 
     before :all do
-      @bucket = 'qiniu_rs_test'
+      @bucket = 'RubySdkTest' + (Time.now.to_i+rand(1000)).to_s
       @key = Digest::SHA1.hexdigest Time.now.to_s
-      @domain = 'cdn.example.com'
-
-      @test_image_bucket = 'test_images_12345'
-      @test_image_key = 'image_logo_for_test.png'
+      @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('./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::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
+      #result = Qiniu::RS.unpublish(@domain)
+      #result.should_not be_false
+
+      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
@@ -58,6 +84,7 @@ module Qiniu
       end
     end
 
+=begin
     context ".set_watermark" do
       it "should works" do
         options = {
@@ -76,6 +103,7 @@ module Qiniu
         puts result.inspect
       end
     end
+=end
 
     context ".put_auth" do
       it "should works" do
@@ -115,7 +143,7 @@ module Qiniu
 
     context ".upload_file" do
       it "should works" do
-        uptoken_opts = {:scope => @bucket}
+        uptoken_opts = {:scope => @bucket, :escape => 0}
         upload_opts = {
           :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
           :file => __FILE__,
@@ -127,6 +155,64 @@ module Qiniu
         result.should_not be_false
         puts result.inspect
       end
+
+      it "should raise MissingArgsError" do
+        uptoken_opts = {:scope => @bucket, :escape => 0}
+        upload_opts = {
+          :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
+          :file => __FILE__,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        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::RS.generate_upload_token(uptoken_opts),
+          :file => 'no_this_file',
+          :bucket => @bucket,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        lambda { Qiniu::RS.upload_file(upload_opts) }.should raise_error(RS::NoSuchFileError)
+      end
+    end
+
+    context ".resumable_upload_file" do
+      it "should works" do
+        # generate bigfile for testing
+        localfile = "test_bigfile"
+        File.open(localfile, "w"){|f| 5242888.times{f.write(rand(9).to_s)}}
+        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::RS.generate_upload_token(uptoken_opts)
+        # uploading
+        upload_opts = {
+            :uptoken => uptoken,
+            :file => localfile,
+            :bucket => @bucket,
+            :key => key
+        }
+        #uploading
+        result1 = Qiniu::RS.upload_file(upload_opts)
+        #drop the bigfile
+        File.unlink(localfile) if File.exists?(localfile)
+        #expect
+        puts result1.inspect
+        result1.should_not be_false
+        result1.should_not be_empty
+        #stat
+        result2 = Qiniu::RS.stat(@bucket, key)
+        puts result2.inspect
+        result2.should_not be_false
+        #delete
+        result3 = Qiniu::RS.delete(@bucket, key)
+        puts result3.inspect
+        result3.should_not be_false
+      end
     end
 
     context ".stat" do
@@ -192,19 +278,69 @@ module Qiniu
       end
     end
 
+=begin
     context ".publish" do
       it "should works" do
         result = Qiniu::RS.publish(@domain, @bucket)
         result.should_not be_false
       end
     end
+=end
 
+=begin
     context ".unpublish" do
       it "should works" do
         result = Qiniu::RS.unpublish(@domain)
         result.should_not be_false
       end
     end
+=end
+
+    context ".batch_copy" do
+      it "should works" do
+        result = Qiniu::RS.batch_copy [@bucket, @key, @bucket, @key2]
+        result.should_not be_false
+
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
+        #result2.should_not be_false
+      end
+    end
+
+    context ".batch_move" do
+      it "should works" do
+        result = Qiniu::RS::RS.batch_move [@bucket, @key, @bucket, @key2]
+        result.should_not be_false
+
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
+        #result2.should_not be_false
+
+        result3 = Qiniu::RS.batch_move [@bucket, @key2, @bucket, @key]
+        result3.should_not be_false
+      end
+    end
+
+    context ".move" do
+      it "should works" do
+        result = Qiniu::RS.move(@bucket, @key, @bucket, @key2)
+        result.should_not be_false
+
+        result2 = Qiniu::RS.stat(@bucket, @key2)
+        result2.should_not be_false
+
+        result3 = Qiniu::RS.move(@bucket, @key2, @bucket, @key)
+        result3.should_not be_false
+      end
+    end
+
+    context ".copy" do
+      it "should works" do
+        result = Qiniu::RS.copy(@bucket, @key, @bucket, @key2)
+        result.should_not be_false
+
+        #result2 = Qiniu::RS.stat(@bucket, @key2)
+        #result2.should_not be_false
+      end
+    end
 
     context ".delete" do
       it "should works" do
@@ -251,10 +387,6 @@ module Qiniu
         data.should_not be_empty
         puts data.inspect
 
-        dest_bucket = "test_thumbnails_bucket"
-        result = Qiniu::RS.mkbucket(dest_bucket)
-        result.should_not be_false
-
         dest_key = "cropped-" + @test_image_key
         src_img_url = data["url"]
         mogrify_options = {
@@ -266,7 +398,7 @@ module Qiniu
           :format => "jpg",
           :auto_orient => true
         }
-        result2 = Qiniu::RS.image_mogrify_save_as(dest_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
@@ -275,9 +407,19 @@ module Qiniu
 
     context ".generate_upload_token" do
       it "should works" do
-        data = Qiniu::RS.generate_upload_token({:scope => 'test_bucket', :expires_in => 3600})
+        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
+      end
+    end
+
+    context ".generate_download_token" do
+      it "should works" do
+        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
       end
     end
 

spec/qiniu/tokens/qbox_token_spec.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/tokens/qbox_token'
+
+module Qiniu
+  module RS
+    describe QboxToken do
+      before :all do
+        @qbox_token = QboxToken.new(:url => 'www.qiniutek.com?key1=value1',
+                                    :params => { :key2 => 'value2' })
+        @qbox_token.access_key = 'access_key'
+        @qbox_token.secret_key = 'secret_key'
+      end
+
+      context "#generate_token" do
+        it "should generate token" do
+          @qbox_token.generate_token.should_not be_empty
+        end
+      end
+
+      context "#generate_signature" do
+        it "should generate signature" do
+          @qbox_token.generate_signature.should == "www.qiniutek.com?key1=value1\nkey2=value2"
+        end
+      end
+    end
+  end
+end

spec/spec_helper.rb

@@ -6,13 +6,6 @@ require 'rspec'
 
 RSpec.configure do |config|
   config.before :all do
-    Qiniu::RS.establish_connection! :access_key => "dFX_wMGVrRzwdWaraW-Qe5ZCDT-kcSmIAGKQOkXh",
-                                    :secret_key => "VllxxDfkn_h2ZIqeKYTnHJiN4LVODfDBlJHy_KsW",
-                                    :auth_url   => "http://m1.qbox.me:13001/oauth2/token",
-                                    :rs_host    => "http://m1.qbox.me:13003",
-                                    :io_host    => "http://m1.qbox.me:13004",
-                                    :up_host    => "http://m1.qbox.me:13019",
-                                    :pub_host   => "http://m1.qbox.me:13012",
-                                    :eu_host    => "http://m1.qbox.me:13050"
+    Qiniu::RS.establish_connection! :access_key => ENV["QINIU_ACCESS_KEY"], :secret_key => ENV["QINIU_SECRET_KEY"]
   end
 end