oss-ruby-sdk 0.1.0

data/lib/oss/client.rb

@@ -0,0 +1,206 @@
+require 'rest-client'
+require 'digest/md5'
+require 'openssl'
+require 'base64'
+require 'nokogiri'
+require 'oss/error'
+
+module Oss
+
+  class Client
+
+    attr_reader :endpoint, :access_key_id, :access_key_secret
+    attr_accessor :debug_mode
+
+    def initialize(endpoint, access_key_id, access_key_secret, debug_mode = false)
+      @debug_mode        = debug_mode
+      @endpoint          = endpoint
+      @access_key_id     = access_key_id
+      @access_key_secret = access_key_secret
+    end
+
+    # http put request
+    def put(options = {})
+      request_prepare(:put, options)
+    end
+
+    # http get request
+    def get(options = {})
+      request_prepare(:get, options)
+    end
+
+    # http post request
+    def post(options = {})
+      request_prepare(:post, options)
+    end
+
+    # http delete request
+    def delete(options = {})
+      request_prepare(:delete, options)
+    end
+
+    # http delete request
+    def head(options = {})
+      request_prepare(:head, options)
+    end
+
+    # http delete request
+    def options(options = {})
+      request_prepare(:options, options)
+    end
+
+    def request_prepare(method, options)
+      # set header sign
+      options[:sign_configs] ||= Hash.new
+      options[:sign_configs][:date] = gmt_date
+      options[:sign_configs][:host] = options[:host]
+      options[:sign_configs][:path] = options[:path]
+      options[:sign_configs][:verb] = method.to_s.upcase
+
+      # content md5 check if need
+      if options[:content_md5_check]
+        # payload make md digest
+        md5 = Digest::MD5.digest(options[:payload])
+
+        # then make base64 and trim \n
+        cm = Base64.encode64(md5).gsub("\n", '')
+        options[:sign_configs][:content_md5] = cm
+
+        # set to header
+        options[:headers] ||= Hash.new
+        options[:headers]['Content-MD5'] = cm
+      end
+
+      # set header content length if need
+      if options[:content_length_check]
+        options[:payload] ||= ''
+        options[:headers]['Content-Length'] = options[:payload].bytesize
+      end
+
+      # set get path query string
+      path = Util.set_query_string(options[:path], options[:query_string])
+
+      # add query string to sign if need
+      if options[:sign_configs][:sign_query_string]
+        options[:sign_configs][:path] = path
+      end
+
+      # create sign header
+      signed_header = set_header_sign(options[:headers], options[:sign_configs])
+
+      # send request
+      request(options[:host], path, signed_header, options[:as] || :xml) do |url, header|
+
+        # use RestClient send request
+        RestClient::Request.execute(url: url, method: method, headers: header, payload: options[:payload])
+
+      end
+    end
+
+    def request(host, path, headers, as = :xml, &block)
+      url = "http://#{host}#{path}"
+
+      # send request and rescue errors
+      begin
+        response = yield(url, headers)
+      rescue RestClient::ExceptionWithResponse => err
+        response = err.response
+      end
+
+      p "DEBUG: response body =======>\n#{response.body}\n" if debug_mode
+
+      if response.code/100 != 2
+        # error response
+        error_handler(response)
+      else
+        # success response
+        case as
+          when :xml
+            # parse as xml object
+            Nokogiri::XML(response.body)
+          when :raw
+            # return raw response
+            response
+          else
+            raise 'Undefined request as param!'
+        end
+      end
+
+    end
+
+
+    private
+
+    def error_handler(response)
+      xml_doc  = Nokogiri::XML(response.body)
+
+      # parse all error infos
+      error_attrs = {
+          http_status: response.code,
+          code:        xml_doc.xpath('Error/Code').inner_text,
+          message:     xml_doc.xpath('Error/Message').inner_text,
+          header:      xml_doc.xpath('Error/Header').inner_text,
+          request_id:  xml_doc.xpath('Error/RequestId').inner_text,
+          host_id:     xml_doc.xpath('Error/HostId').inner_text
+      }
+
+      # error raise format
+      status     = "HttpStatus: #{error_attrs[:http_status]}\n"
+      code       = "Code: #{error_attrs[:code]}\n"
+      message    = "Message: #{error_attrs[:message]}\n"
+      header     = error_attrs[:header] == '' ? '' : "Header: #{error_attrs[:header]}\n"
+      request_id = "RequestId: #{error_attrs[:request_id]}\n"
+      host       = "HostId: #{error_attrs[:host_id]}\n"
+
+      error_info = "\n#{status}#{code}#{message}#{header}#{request_id}#{host}\n"
+
+      # raise error
+      raise ResponseError.new(error_attrs, error_info)
+    end
+
+    def set_header_sign(origin_header, configs = {})
+      # new hash if not exist
+      origin_header = Hash.new if origin_header.nil?
+
+      # set authorization signature header
+      origin_header['Authorization'] = signature(
+          configs[:verb],
+          configs[:date],
+          "#{configs[:resource]}#{configs[:path]}",
+          configs[:content_md5],
+          configs[:content_type],
+          configs[:oss_headers]
+      )
+
+      # set server headers
+      origin_header['Host'] = configs[:host]
+      origin_header['Date'] = configs[:date]
+      origin_header
+    end
+
+    def signature(verb, date, resource = '', content_md5 = '', content_type = '', oss_headers = '')
+      # set oss headers like x-oss-something into sign
+      oss_headers << "\n" if oss_headers != nil and oss_headers != ''
+
+      # string ready to sign
+      string_to_sign = "#{verb}\n#{content_md5}\n#{content_type}\n#{date}\n#{oss_headers}#{resource}"
+
+      p "DEBUG: client sign string =======>\n#{string_to_sign}\n" if debug_mode
+
+      # use hmac-sha1 then base64
+      digest = OpenSSL::Digest.new('sha1')
+      h = OpenSSL::HMAC.digest(digest, access_key_secret, string_to_sign)
+      b = Base64.encode64(h)
+
+      # final signature Authorization value
+      "OSS #{access_key_id}:#{b.gsub("\n", '')}"
+    end
+
+    # create GMT date format
+    def gmt_date
+      Time.now.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    end
+
+  end
+
+end

data/lib/oss/cors.rb

@@ -0,0 +1,106 @@
+require 'oss/client'
+require 'oss/util'
+
+module Oss
+
+  class Cors
+
+    include Util
+
+    attr_accessor :client, :xml_obj
+
+    def initialize(client)
+      @client = client
+    end
+
+    def put_bucket_cors(bucket_name, rules)
+      # sign configs
+      sign_configs = Hash.new
+      sign_configs[:resource]             = "/#{bucket_name}"
+      sign_configs[:content_type]         = 'application/x-www-form-urlencoded'
+      sign_configs[:content_length_check] = true
+
+      # build payload xml
+      payload = Nokogiri::XML::Builder.new do |xml|
+        xml.CORSConfiguration do
+          rules.each do |rule|
+            xml.CORSRule do
+              rule.each do |a_rule|
+                xml.send(a_rule[:key], a_rule[:value])
+              end
+            end
+          end
+        end
+      end
+
+      @xml_obj = client.put(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: '/?cors',
+          sign_configs: sign_configs,
+          payload: payload.to_xml
+      )
+
+      true
+    end
+
+    def get_bucket_cors(bucket_name)
+      @xml_obj = client.get(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          sign_configs: {resource: "/#{bucket_name}"},
+          path:         '/?cors',
+      )
+
+      rules = Array.new
+      @xml_obj.xpath('CORSConfiguration/CORSRule').each do |rule|
+        rules << rule
+      end
+
+      rules
+    end
+
+    def delete_bucket_cors(bucket_name)
+      client.delete(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         '/?cors',
+          sign_configs: {resource: "/#{bucket_name}"},
+      )
+
+      true
+    end
+
+    def option_object(bucket_name, object_name, origin, request_method, request_headers)
+      # sign configs
+      sign_configs = Hash.new
+      sign_configs[:resource] = "/#{bucket_name}"
+
+      headers = Hash.new
+      headers['Origin'] = origin
+      headers['Access-Control-Request-Method']  = request_method
+      headers['Access-Control-Request-Headers'] = request_headers
+
+      resp = client.options(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          sign_configs: sign_configs,
+          headers:      headers,
+          as:           :raw
+      )
+
+      # return response header
+      resp.headers
+    end
+
+    def method_missing(method)
+      if @xml_obj.nil?
+        super
+      else
+        camel = Util.camelize(method)
+        value = @xml_obj.xpath(camel)
+        raise "missing xml attribute #{camel}" if value.length == 0
+        value.inner_text
+      end
+    end
+
+  end
+
+end

data/lib/oss/error.rb

@@ -0,0 +1,20 @@
+module Oss
+
+  class ResponseError < StandardError
+
+    attr_reader :http_status, :error_code, :error_message, :header, :request_id, :host_id
+
+    def initialize(err_attrs, err_msg)
+      @error_code    = err_attrs[:code]
+      @error_message = err_attrs[:message]
+      @http_status   = err_attrs[:http_status]
+      @header        = err_attrs[:header]
+      @request_id    = err_attrs[:request_id]
+      @host_id       = err_attrs[:host_id]
+
+      super err_msg
+    end
+
+  end
+
+end

data/lib/oss/multipart.rb

@@ -0,0 +1,225 @@
+require 'oss/client'
+require 'oss/util'
+
+module Oss
+
+  class Multipart
+
+    include Util
+
+    attr_accessor :client, :xml_obj
+
+    def initialize(client)
+      @client = client
+    end
+
+    def initiate_multipart_upload(bucket_name, object_name, options = {})
+      # set header
+      headers = Util.hash_filter(options, {
+                                            expires:             'Expires',
+                                            content_control:     'Cache-Control',
+                                            content_encoding:    'Content-Encoding',
+                                            content_disposition: 'Content-Disposition',
+                                            encryption:          'x-oss-server-side-encryption',
+                                        })
+
+      # sign configs
+      sign_configs = {
+          resource:     "/#{bucket_name}",
+          content_type: 'application/x-www-form-urlencoded',
+          oss_headers:  Util.oss_headers_to_s(options, {
+                                                         encryption: 'x-oss-server-side-encryption',
+                                                     })
+      }
+
+      @xml_obj = client.post(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}?uploads",
+          headers:      headers,
+          sign_configs: sign_configs,
+      ).xpath('InitiateMultipartUploadResult')
+
+      # return init info
+      {
+        bucket:    @xml_obj.xpath('Bucket').text,
+        key:       @xml_obj.xpath('Key').text,
+        upload_id: @xml_obj.xpath('UploadId').text,
+      }
+    end
+
+    def upload_part(bucket_name, object_name, upload_id, file, part_number = 1, options = {})
+      # sign configs
+      sign_configs = {
+          resource:              "/#{bucket_name}",
+          content_type:          'application/x-www-form-urlencoded',
+          content_length_check:  true,
+          content_md5_check:     options[:content_md5_check],
+          sign_query_string:     true
+      }
+
+      resp = client.put(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          sign_configs: sign_configs,
+          query_string: {'partNumber' => part_number, 'uploadId' => upload_id},
+          payload:      file,
+          as:           :raw
+      )
+
+      {etag: resp.headers[:etag],  part_number: part_number}
+    end
+
+    def upload_part_copy(bucket_name, object_name, upload_id, old_bucket, old_object, part_number = 1, options = {})
+      # copy source format
+      options[:copy_source] = "/#{old_bucket}/#{old_object}"
+      options[:copy_source_range] = "bytes=#{options[:copy_source_begin]}-#{options[:copy_source_end]}" unless options[:copy_source_begin].nil?
+
+      # set header
+      headers = Util.hash_filter(options, {
+                                            if_modified_since:   'x-oss-copy-source-if-modified-since',
+                                            if_unmodified_since: 'x-oss-copy-source-if-unmodified-since',
+                                            if_match:            'x-oss-copy-source-if-match',
+                                            if_none_match:       'x-oss-copy-source-if-none-match',
+                                            copy_source:         'x-oss-copy-source',
+                                            copy_source_range:   'x-oss-copy-source-range'
+                                        })
+
+      # sign configs
+      sign_configs = {
+          resource:          "/#{bucket_name}",
+          sign_query_string: true,
+          content_type:      'application/x-www-form-urlencoded',
+          oss_headers:       Util.oss_headers_to_s(options, {
+                                                        if_modified_since:   'x-oss-copy-source-if-modified-since',
+                                                        if_unmodified_since: 'x-oss-copy-source-if-unmodified-since',
+                                                        if_match:            'x-oss-copy-source-if-match',
+                                                        if_none_match:       'x-oss-copy-source-if-none-match',
+                                                        copy_source:         'x-oss-copy-source',
+                                                        copy_source_range:   'x-oss-copy-source-range'
+                                                    })
+      }
+
+      @xml_obj = client.put(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          headers:      headers,
+          sign_configs: sign_configs,
+          query_string: {'partNumber' => part_number, 'uploadId' => upload_id},
+      )
+
+      {
+          last_modify: @xml_obj.xpath('CopyPartResult/LastModified').text,
+          etag:        @xml_obj.xpath('CopyPartResult/ETag').text,
+      }
+    end
+
+    def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+      # build payload xml
+      payload = Nokogiri::XML::Builder.new do
+        CompleteMultipartUpload do
+          parts.each do |part|
+            Part do
+              PartNumber part[:part_number]
+              ETag part[:etag]
+            end
+          end
+        end
+      end
+
+      @xml_obj = client.post(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          sign_configs: {resource: "/#{bucket_name}", sign_query_string: true, content_type: 'application/x-www-form-urlencoded',},
+          query_string: {'uploadId' => upload_id},
+          payload:      payload.to_xml
+      ).xpath('CompleteMultipartUploadResult')
+
+      # return object info
+      {
+          location: @xml_obj.xpath('Location').text,
+          bucket:   @xml_obj.xpath('Bucket').text,
+          key:      @xml_obj.xpath('Key').text,
+          etag:     @xml_obj.xpath('ETag').text,
+      }
+    end
+
+    def abort_multipart_upload(bucket_name, object_name, upload_id)
+
+      client.delete(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          sign_configs: {resource: "/#{bucket_name}", sign_query_string: true},
+          query_string: {'uploadId' => upload_id},
+      )
+
+      true
+    end
+
+    def list_multipart_upload(bucket_name, options = {})
+      @xml_obj = client.get(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          sign_configs: {resource: "/#{bucket_name}"},
+          path:         '/?uploads',
+          query_string: options
+      ).xpath('ListMultipartUploadsResult')
+
+      self
+    end
+
+    def uploads
+      uploads = @xml_obj.xpath('Upload')
+      results = Array.new
+
+      # parse as array
+      uploads.each do |upload|
+        results << {
+            key:       upload.xpath('Key').text,
+            upload_id: upload.xpath('UploadId').text,
+            initiated: upload.xpath('Initiated').text,
+        }
+      end
+      results
+    end
+
+    def list_parts(bucket_name, object_name, options = {})
+      @xml_obj = client.get(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object_name}",
+          query_string: options,
+          sign_configs: {resource: "/#{bucket_name}", sign_query_string: true},
+      ).xpath('ListPartsResult')
+
+      self
+    end
+
+    def parts
+      parts = @xml_obj.xpath('Part')
+      results = Array.new
+
+      # parse as array
+      parts.each do |part|
+        results << {
+            part_number:   part.xpath('PartNumber').text,
+            last_modified: part.xpath('LastModified').text,
+            etag:          part.xpath('ETag').text,
+            size:          part.xpath('Size').text,
+        }
+      end
+      results
+    end
+
+
+    def method_missing(method)
+      if @xml_obj.nil?
+        super
+      else
+        camel = Util.camelize(method)
+        value = @xml_obj.xpath(camel)
+        raise "missing xml attribute #{camel}" if value.length == 0
+        value.inner_text
+      end
+    end
+
+  end
+
+end