qiniu_jxb 6.2.4

data/lib/qiniu/config.rb

@@ -0,0 +1,58 @@
+# -*- 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 'tmpdir'
+
+module Qiniu
+    module Config
+      class << self
+
+        DEFAULT_OPTIONS = {
+          :user_agent      => 'QiniuRuby/' + Version.to_s + ' ('+RUBY_PLATFORM+')' + ' Ruby/'+ RUBY_VERSION,
+          :method          => :post,
+          :content_type    => 'application/x-www-form-urlencoded',
+          :auth_url        => "https://acc.qbox.me/oauth2/token",
+          :rs_host         => "http://rs.qiniu.com",
+          :up_host         => "http://up.qiniu.com",
+          :pub_host        => "http://pu.qbox.me:10200",
+          :eu_host         => "http://eu.qbox.me",
+          :access_key      => "",
+          :secret_key      => "",
+          :auto_reconnect  => true,
+          :max_retry_times => 3,
+          :block_size      => 1024*1024*4,
+          :chunk_size      => 1024*256,
+          :enable_debug    => true,
+          :tmpdir          => Dir.tmpdir + File::SEPARATOR + 'QiniuRuby'
+        }
+
+        REQUIRED_OPTION_KEYS = [:access_key, :secret_key]
+
+        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 # module Config
+end # module Qiniu

data/lib/qiniu/exceptions.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+
+    class Exception < RuntimeError
+    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}. Response body: #{http_body}"
+      end
+
+      def to_s
+        message
+      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 ')
+        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 # module Qiniu

data/lib/qiniu/fop.rb

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

data/lib/qiniu/http.rb

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

data/lib/qiniu/image.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module Fop
+    module Image
+      class << self
+        include Utils
+
+        def info(url)
+          return HTTP.api_get(url + '?imageInfo')
+        end # info
+
+        def exif(url)
+          return HTTP.api_get(url + '?exif')
+        end # exif
+
+        def mogrify_preview_url(source_image_url, options)
+          source_image_url + '?' + generate_mogrify_params_string(options)
+        end
+
+        def generate_mogrify_params_string(options = {})
+          opts = {}
+          options.each do |k, v|
+            opts[k.to_s] = v
+          end
+          params_string = ""
+          keys = ["thumbnail", "gravity", "crop", "quality", "rotate", "format"]
+          keys.each do |key|
+            params_string += %Q(/#{key}/#{opts[key]}) unless opts[key].nil?
+          end
+          params_string += '/auto-orient' unless opts["auto_orient"].nil?
+          'imageMogr' + URI.escape(params_string)
+        end
+
+      end
+    end # module Image
+  end # module Fop
+end # module Qiniu

data/lib/qiniu/log.rb

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

data/lib/qiniu/management.rb

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+# vim: sw=2 ts=2
+
+require 'qiniu/http'
+
+module Qiniu
+    module Storage
+      class << self
+        include Utils
+
+        public
+        def buckets
+          url = Config.settings[:rs_host] + '/buckets'
+          return HTTP.management_post(url)
+        end # buckets
+
+        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 stat(bucket, key)
+          url = Config.settings[:rs_host] + '/stat/' + encode_entry_uri(bucket, key)
+          return HTTP.management_post(url)
+        end # stat
+
+        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
+
+        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
+
+        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
+
+        def delete(bucket, key)
+          url = Config.settings[:rs_host] + '/delete/' + encode_entry_uri(bucket, key)
+          return HTTP.management_post(url)
+        end # delete
+
+        def drop(bucket)
+          url = Config.settings[:rs_host] + "/drop/#{bucket}"
+          return HTTP.management_post(url)
+        end # drop
+
+        def batch(command, bucket, keys)
+          execs = []
+          keys.each do |key|
+            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
+
+        def batch_get(bucket, keys)
+          batch("get", bucket, keys)
+        end # batch_get
+
+        def batch_stat(bucket, keys)
+          batch("stat", bucket, keys)
+        end # batch_stat
+
+        def batch_copy(*args)
+          _batch_cp_or_mv('copy', args)
+        end # batch_copy
+
+        def batch_move(*args)
+          _batch_cp_or_mv('move', args)
+        end # batch_move
+
+        def batch_delete(bucket, keys)
+          batch("delete", bucket, keys)
+        end # batch_delete
+
+        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
+
+        def image_mogrify_save_as(bucket, key, source_image_url, options)
+          mogrify_params_string = Fop::Image.generate_mogrify_params_string(options)
+          save_as(bucket, key, source_image_url, mogrify_params_string)
+        end # image_mogrify_save_as
+
+        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 # _generate_cp_or_mv_opstr
+
+        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 
+          url = Config.settings[:rs_host] + "/batch"
+          return HTTP.management_post(url, execs.join("&"))
+        end # _batch_cp_or_mv
+      end
+    end # module Storage
+end # module Qiniu