qiniu-s3 0.1.2

data/lib/qiniu/s3/io.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'mime/types'
+require 'digest/sha1'
+require 'qiniu/s3/exceptions'
+
+module Qiniu
+  module S3
+    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/s3/log.rb

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

data/lib/qiniu/s3/rs.rb

@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module S3
+    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/s3/utils.rb

@@ -0,0 +1,124 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'json'
+require 'base64'
+require 'rest_client'
+require 'qiniu/s3/exceptions'
+
+module Qiniu
+  module S3
+    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/s3/version.rb

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

data/qiniu-s3.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/qiniu/s3/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["why404"]
+  gem.email         = ["why404@gmail.com"]
+  gem.description   = %q{Qiniu Cloud Storage SDK for Ruby. See: http://docs.qiniutek.com/v1/sdk/ruby/}
+  gem.summary       = %q{Qiniu Cloud Storage SDK for Ruby}
+  gem.homepage      = "https://github.com/why404/qiniu-s3-sdk-for-ruby"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "qiniu-s3"
+  gem.require_paths = ["lib"]
+  gem.version       = Qiniu::S3::VERSION
+
+  # specify any dependencies here; for example:
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "fakeweb"
+  gem.add_runtime_dependency "rest-client"
+  gem.add_runtime_dependency "mime-types"
+end

data/spec/qiniu/s3/auth_spec.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/s3/auth'
+
+module Qiniu
+  module S3
+    describe Auth do
+
+      before :all do
+        @username = "test@qbox.net"
+        @password = "test"
+
+        code, data = Qiniu::S3::Auth.exchange_by_password!(@username, @password)
+        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
+
+        @access_token = data["access_token"]
+        @refresh_token = data["refresh_token"]
+        puts data.inspect
+      end
+
+      context ".exchange_by_password" do
+        it "should sign in failed when pass a non-existent username" do
+          code, data = Qiniu::S3::Auth.exchange_by_password!("a_non_existent_user@example.com", "password")
+          code.should == 401
+          data["error_code"].should == 11
+          data["error"].should == "failed_authentication"
+          puts data.inspect
+        end
+
+        it "should sign in failed when pass a wrong password" do
+          code, data = Qiniu::S3::Auth.exchange_by_password!(@username, "a-wrong-password")
+          code.should == 401
+          data["error_code"].should == 11
+          data["error"].should == "failed_authentication"
+          puts data.inspect
+        end
+      end
+
+      context ".exchange_by_refresh_token" do
+        it "should works" do
+          @refresh_token.should_not be_empty
+          code, data = Qiniu::S3::Auth.exchange_by_refresh_token!(@refresh_token)
+          code.should == 200
+          data["access_token"].should_not be_empty
+          data["refresh_token"].should_not be_empty
+          data["expires_in"].should_not be_zero
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

data/spec/qiniu/s3/image_spec.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/s3/auth'
+require 'qiniu/s3/rs'
+require 'qiniu/s3/image'
+
+module Qiniu
+  module S3
+    describe Image do
+
+      before :all do
+        code, data = Qiniu::S3::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
+
+        @bucket = "test_images"
+        @key = "test_image.jpg"
+        code2, data2 = Qiniu::S3::RS.get(@bucket, @key)
+        code2.should == 200
+        data2["url"].should_not be_empty
+        puts data2.inspect
+
+        @download_url = data2["url"]
+      end
+
+      context ".info" do
+        it "should works" do
+          code, data = Qiniu::S3::Image.info(@download_url)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

data/spec/qiniu/s3/io_spec.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/s3/auth'
+require 'qiniu/s3/io'
+require 'digest/sha1'
+
+module Qiniu
+  module S3
+    describe IO do
+
+      before :all do
+        code, data = Qiniu::S3::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
+
+        code2, data2 = Qiniu::S3::IO.put_auth()
+        code2.should == 200
+        data2["url"].should_not be_empty
+        data2["expiresIn"].should_not be_zero
+        puts data2.inspect
+
+        @put_url = data2["url"]
+        @bucket = "test"
+        @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
+      end
+
+      context ".put_file" do
+        it "should works" do
+          code, data = Qiniu::S3::IO.put_file(@put_url, __FILE__, @bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

data/spec/qiniu/s3/rs_spec.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+require 'digest/sha1'
+require 'spec_helper'
+require 'qiniu/s3/auth'
+require 'qiniu/s3/io'
+require 'qiniu/s3/rs'
+
+module Qiniu
+  module S3
+    describe RS do
+
+      before :all do
+        code, data = Qiniu::S3::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
+
+        code2, data2 = Qiniu::S3::IO.put_auth()
+        code2.should == 200
+        data2["url"].should_not be_empty
+        data2["expiresIn"].should_not be_zero
+        puts data2.inspect
+
+        @put_url = data2["url"]
+        @bucket = "test"
+        @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
+        @domain = 'cdn.example.com'
+      end
+
+      context "IO.put_file" do
+        it "should works" do
+          code, data = Qiniu::S3::IO.put_file(@put_url, __FILE__, @bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".stat" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.stat(@bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".get" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.get(@bucket, @key, "rs_spec.rb", 1)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.batch("stat", @bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch_stat" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.batch_stat(@bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".batch_get" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.batch_get(@bucket, [@key])
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".publish" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.publish(@domain, @bucket)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".unpublish" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.unpublish(@domain)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".delete" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.delete(@bucket, @key)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".drop" do
+        it "should works" do
+          code, data = Qiniu::S3::RS.drop(@bucket)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end