qiniu-rs 1.0.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.swp
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--colour -f nested

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qiniu-s3.gemspec
+gemspec
+
+gem "rake", "~> 0.9"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 why404
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# 关于
+
+此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x 版本，基于 [七牛云存储官方API](http://docs.qiniutek.com/v1/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
+
+## 安装
+
+在您 Ruby 应用程序的 `Gemfile` 文件中，添加如下一行代码：
+
+    gem 'qiniu-rs'
+
+然后，在应用程序所在的目录下，可以运行 `bundle` 安装依赖包：
+
+    $ bundle
+
+或者，可以使用 Ruby 的包管理器 `gem` 进行安装：
+
+    $ gem install qiniu-rs
+
+## 使用
+
+参考文档：[七牛云存储 Ruby SDK 使用指南](http://docs.qiniutek.com/v1/sdk/ruby/)
+
+## 贡献代码
+
+1. Fork
+2. 创建您的特性分支 (`git checkout -b my-new-feature`)
+3. 提交您的改动 (`git commit -am 'Added some feature'`)
+4. 将您的修改记录提交到远程 `git` 仓库 (`git push origin my-new-feature`)
+5. 然后到 github 网站的该 `git` 远程仓库的 `my-new-feature` 分支下发起 Pull Request
+
+## 许可证
+
+Copyright (c) 2012 why404
+
+基于 MIT 协议发布:
+
+* [www.opensource.org/licenses/MIT](http://www.opensource.org/licenses/MIT)
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/qiniu/rs/auth.rb

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+
+require 'qiniu/rs/exceptions'
+
+module Qiniu
+  module RS
+    module Auth
+      class << self
+        include Utils
+
+        def exchange_by_password!(username, password)
+          @username = username
+          @password = password
+          post_data = {
+            :client_id  => Config.settings[:client_id],
+            :grant_type => "password",
+            :username   => username,
+            :password   => password
+          }
+          code, data = http_request Config.settings[:auth_url], post_data
+          reset_token(data["access_token"], data["refresh_token"]) if code == 200
+          [code, data]
+        end
+
+        def exchange_by_refresh_token!(refresh_token)
+          post_data = {
+            :client_id     => Config.settings[:client_id],
+            :grant_type    => "refresh_token",
+            :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
+          [code, data]
+        end
+
+        def reset_token(access_token, refresh_token)
+          @access_token  = access_token
+          @refresh_token = refresh_token
+        end
+
+        def call(url, data, retry_times = 0)
+          raise MissingAccessToken if @access_token.nil?
+          code, data = http_request url, data, {:access_token => @access_token}
+          if code == 401
+            raise MissingRefreshToken if @refresh_token.nil?
+            code, data = exchange_by_refresh_token!(@refresh_token)
+            if code == 401
+              raise MissingUsernameOrPassword if (@username.nil? || @password.nil?)
+              code, data = exchange_by_password!(@username, @password)
+            end
+            if code == 200
+              retry_times += 1
+              if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
+                return call(url, data, retry_times)
+              end
+            end
+          end
+          [code, data]
+        end
+
+        def request(url, data = nil)
+          begin
+            code, data = Auth.call(url, data)
+          rescue [MissingAccessToken, MissingRefreshToken, MissingUsernameOrPassword] => e
+            Log.logger.error e
+            code, data = 401, {}
+          end
+          [code, data]
+        end
+
+      end
+    end
+  end
+end

data/lib/qiniu/rs/config.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+#
+# USAGE WAY 1:
+# Qbox::Config.initialize_connect :client_id => "<ClientID>",
+#                                 :client_secret => "<ClientSecret>"
+#
+# USAGE WAY 2:
+# Qbox::Config.load "path/to/your_project/config/qiniu.yml"
+#
+
+require "qiniu/rs/version"
+
+module Qiniu
+  module RS
+    module Config
+      class << self
+
+        DEFAULT_OPTIONS = {
+          :user_agent      => 'Qiniu-RS-Ruby-SDK-' + VERSION + '()',
+          :method          => :post,
+          :content_type    => 'application/x-www-form-urlencoded',
+          :auth_url        => "https://acc.qbox.me/oauth2/token",
+          :rs_host         => "http://rs.qbox.me:10100",
+          :io_host         => "http://io.qbox.me",
+          :client_id       => "<YOUR_APP_CLIENT_ID>",
+          :client_secret   => "<YOUR_APP_CLIENT_SECRET>",
+          :auto_reconnect  => true,
+          :max_retry_times => 5
+        }
+
+        REQUIRED_OPTION_KEYS = [:client_id, :client_secret, :auth_url, :rs_host, :io_host]
+
+        attr_reader :settings, :default_params
+
+        def load config_file
+          if File.exist?(config_file)
+            config_options = YAML.load_file(config_file)
+            initialize_connect(config_options)
+          else
+            raise MissingConfError, config_file
+          end
+        end
+
+        def initialize_connect options = {}
+          @settings = DEFAULT_OPTIONS.merge(options)
+          REQUIRED_OPTION_KEYS.each do |opt|
+            raise MissingArgsError, [opt] unless @settings.has_key?(opt)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/qiniu/rs/exceptions.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+
+    class Exception < RuntimeError
+      def to_s
+        inspect
+      end
+    end
+
+    class ResponseError < Exception
+      attr_reader :response
+
+      def initialize(message, response = nil)
+        @response = response
+        super(message)
+      end
+
+      def http_code
+        @response.code.to_i if @response
+      end
+
+      def http_body
+        @response.body if @response
+      end
+
+      def inspect
+        "#{message}: #{http_body}"
+      end
+    end
+
+    class RequestFailed < ResponseError
+      def message
+        "HTTP status code #{http_code}"
+      end
+
+      def to_s
+        message
+      end
+    end
+
+    class MissingArgsError < Exception
+      def initialize(missing_keys)
+        key_list = missing_keys.map {|key| key.to_s}.join(' and the ')
+        super("You did not provide both required args. Please provide the #{key_list}.")
+      end
+    end
+
+    class MissingAccessToken < MissingArgsError
+      def initialize
+        super([:access_token])
+      end
+    end
+
+    class MissingRefreshToken < MissingArgsError
+      def initialize
+        super([:refresh_token])
+      end
+    end
+
+    class MissingUsernameOrPassword < MissingArgsError
+      def initialize
+        super([:username, :password])
+      end
+    end
+
+    class InvalidArgsError < Exception
+      def initialize(invalid_keys)
+        key_list = invalid_keys.map {|key| key.to_s}.join(' and the ')
+        super("#{key_list} should not be empty.")
+      end
+    end
+
+    class MissingConfError < Exception
+      def initialize(missing_conf_file)
+        super("Error, missing #{missing_conf_file}. You must have #{missing_conf_file} to configure your client id and secret.")
+      end
+    end
+
+    class NoSuchFileError < Exception
+      def initialize(missing_file)
+        super("Error, no such file #{missing_file}.")
+      end
+    end
+
+  end
+end

data/lib/qiniu/rs/image.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module Image
+      class << self
+        include Utils
+
+        def info(url)
+          Utils.http_request url + '/imageInfo', nil, {:method => :get}
+        end
+
+        def preivew_url(url, spec)
+          url + '/imagePreview/' + spec.to_s
+        end
+
+      end
+    end
+  end
+end

data/lib/qiniu/rs/io.rb

@@ -0,0 +1,41 @@
+# -*- 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 put_file(url, local_file, bucket = '', key = '', mime_type = '', custom_meta = '', callback_params = '')
+          raise NoSuchFileError unless File.exist?(local_file)
+          key = Digest::SHA1.hexdigest(local_file + Time.now.to_s) if key.empty?
+          entry_uri = bucket + ':' + key
+          if 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.empty?
+          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type} if callback_params.empty?
+          callback_query_string = Utils.generate_query_string(callback_params)
+          Utils.upload_multipart_data(url, local_file, action_params, callback_query_string)
+        end
+
+      end
+    end
+  end
+end

data/lib/qiniu/rs/log.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'
+
+module Qiniu
+  module RS
+    module Log
+      class << self
+        attr_accessor :logger
+
+        def logger
+          @logger ||= Logger.new(STDERR)
+        end
+      end
+    end
+  end
+end

data/lib/qiniu/rs/rs.rb

@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module RS
+      class << self
+        include Utils
+
+        def stat(bucket, key)
+          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
+          Auth.request url
+        end
+
+        def delete(bucket, key)
+          Auth.request Config.settings[:rs_host] + '/delete/' + encode_entry_uri(bucket, key)
+        end
+
+        def publish(domain, bucket)
+          encoded_domain = Utils.urlsafe_base64_encode(domain)
+          Auth.request Config.settings[:rs_host] + "/publish/#{encoded_domain}/from/#{bucket}"
+        end
+
+        def unpublish(domain)
+          encoded_domain = Utils.urlsafe_base64_encode(domain)
+          Auth.request Config.settings[:rs_host] + "/unpublish/#{encoded_domain}"
+        end
+
+        def drop(bucket)
+          Auth.request Config.settings[:rs_host] + "/drop/#{bucket}"
+        end
+
+        def batch(command, bucket, keys)
+          execs = []
+          keys.each do |key|
+            encoded_uri = encode_entry_uri(bucket, key)
+            execs << "op=/#{command}/#{encoded_uri}"
+          end
+          Auth.request Config.settings[:rs_host] + "/batch?" + execs.join("&")
+        end
+
+        def batch_get(bucket, keys)
+          batch("get", bucket, keys)
+        end
+
+        def batch_stat(bucket, keys)
+          batch("stat", bucket, keys)
+        end
+
+        def batch_delete(bucket, keys)
+          batch("delete", bucket, keys)
+        end
+
+      end
+    end
+  end
+end

data/lib/qiniu/rs/utils.rb

@@ -0,0 +1,124 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'json'
+require 'base64'
+require 'rest_client'
+require 'qiniu/rs/exceptions'
+
+module Qiniu
+  module RS
+    module Utils extend self
+
+      def urlsafe_base64_encode content
+        Base64.encode64(content).strip.gsub('+', '-').gsub('/','_').gsub(/\r?\n/, '')
+      end
+
+      def urlsafe_base64_decode encoded_content
+        Base64.decode64 encoded_content.gsub('_','/').gsub('-', '+')
+      end
+
+      def encode_entry_uri(bucket, key)
+        entry_uri = bucket + ':' + key
+        urlsafe_base64_encode(entry_uri)
+      end
+
+      def safe_json_parse(data)
+        JSON.parse(data)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def send_request_with url, data = nil, options = {}
+        options[:method] = Config.settings[:method] unless options[:method]
+        options[:content_type] = Config.settings[:content_type] unless options[:content_type]
+        header_options = {
+          :accept => :json,
+          :user_agent => Config.settings[:user_agent]
+        }
+        header_options.merge!('Authorization' => "Bearer #{options[:access_token]}") if options[:access_token]
+        case options[:method]
+        when :get
+          response = RestClient.get url, header_options
+        when :post
+          header_options.merge!(:content_type => options[:content_type])
+          response = RestClient.post url, data, header_options
+        end
+        code = response.respond_to?(:code) ? response.code.to_i : 0
+        if code != 200
+          raise RequestFailed.new(response)
+        else
+          data = {}
+          body = response.respond_to?(:body) ? response.body : {}
+          data = safe_json_parse(body) unless body.empty?
+        end
+        [code, data]
+      end
+
+      def http_request url, data = nil, options = {}
+        retry_times = 0
+        begin
+          retry_times += 1
+          send_request_with url, data, options
+        rescue Errno::ECONNRESET => err
+          if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
+            retry
+          else
+            Log.logger.error err
+          end
+        rescue => e
+          Log.logger.warn "#{e.message} => Utils.http_request('#{url}')"
+          code = 0
+          data = {}
+          body = {}
+          if e.respond_to? :response
+            res = e.response
+            code = res.code.to_i if res.respond_to? :code
+            body = res.respond_to?(:body) ? res.body : ""
+            data = safe_json_parse(body) unless body.empty?
+          end
+          [code, data]
+        end
+      end
+
+      def upload_multipart_data(url, filepath, action_string, callback_query_string = '')
+        code, data = 0, {}
+        begin
+          header_options = {
+            :accept => :json,
+            :user_agent => Config.settings[:user_agent]
+          }
+          post_data = {
+            :file => File.new(filepath, 'rb'),
+            :params => callback_query_string,
+            :action => action_string,
+            :multipart => true
+          }
+          response = RestClient.post url, post_data, header_options
+          body = response.respond_to?(:body) ? response.body : ""
+          data = safe_json_parse(body) unless body.empty?
+          code = response.code.to_i if response.respond_to?(:code)
+        rescue Errno::ECONNRESET => err
+          Log.logger.error err
+        rescue => e
+          Log.logger.warn "#{e.message} => Utils.http_request('#{url}')"
+          res = e.response
+          if e.respond_to? :response
+            res = e.response
+            code = res.code.to_i if res.respond_to? :code
+            body = res.respond_to?(:body) ? res.body : ""
+            data = safe_json_parse(body) unless body.empty?
+          end
+        end
+        [code, data]
+      end
+
+      def generate_query_string(params)
+        return params if params.is_a?(String)
+        total_param = params.map { |key, value| key.to_s+"="+value.to_s }
+        URI.escape(total_param.join("&"))
+      end
+
+    end
+  end
+end

data/lib/qiniu/rs/version.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    VERSION = "1.0.0"
+  end
+end