oss 0.1.1

data/lib/oss/object.rb

@@ -0,0 +1,318 @@
+require 'oss/client'
+require 'oss/util'
+require 'openssl'
+require 'base64'
+
+module Oss
+
+  class Object
+
+    include Util
+
+    attr_accessor :client, :xml_obj
+
+    def initialize(client)
+      @client = client
+    end
+
+    def put_object(bucket_name, object, file, options = {})
+      # set header
+      headers = Util.hash_filter(options, {
+                                            expires:             'Expires',
+                                            content_control:     'Cache-Control',
+                                            content_encoding:    'Content-Encoding',
+                                            content_type:        'Content-Type',
+                                            content_md5:         'Content-MD5',
+                                            content_disposition: 'Content-Disposition',
+                                            encryption:          'x-oss-server-side-encryption',
+                                            acl:                 'x-oss-object-acl',
+                                        })
+
+      # sign configs
+      sign_configs = {
+          resource:              "/#{bucket_name}",
+          content_type:          options[:content_type],
+          content_md5_check:     options[:content_md5_check],
+          content_length_check:  options[:content_length_check],
+          oss_headers:  Util.oss_headers_to_s(options, {
+                                                        acl:        'x-oss-object-acl',
+                                                        encryption: 'x-oss-server-side-encryption',
+                                                    })
+      }
+
+      client.put(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object}",
+          headers:      headers,
+          sign_configs: sign_configs,
+          payload:      file,
+      )
+
+      true
+    end
+
+    def copy_object(bucket_name, object, old_bucket, old_object, options = {})
+      # copy source format
+      options[:copy_source] = "/#{old_bucket}/#{old_object}"
+
+      # set header
+      headers = Util.hash_filter(options, {
+                                            metadata_directive:  'x-oss-metadata-directive',
+                                            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',
+                                            encryption:          'x-oss-server-side-encryption',
+                                            acl:                 'x-oss-object-acl',
+                                            copy_source:         'x-oss-copy-source'
+                                        })
+
+      # sign configs
+      sign_configs = {
+          resource:     "/#{bucket_name}",
+          content_type: 'application/x-www-form-urlencoded',
+          oss_headers:  Util.oss_headers_to_s(options, {
+                                                         metadata_directive:  'x-oss-metadata-directive',
+                                                         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',
+                                                         encryption:          'x-oss-server-side-encryption',
+                                                         acl:                 'x-oss-object-acl',
+                                                         copy_source:         'x-oss-copy-source'
+                                                     })
+      }
+
+      @xml_obj = client.put(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object}",
+          headers:      headers,
+          sign_configs: sign_configs,
+      )
+
+      {
+          last_modify: @xml_obj.xpath('CopyObjectResult/LastModified').text,
+          etag:        @xml_obj.xpath('CopyObjectResult/ETag').text,
+      }
+    end
+
+    def get_object(bucket_name, object, options = {})
+      # set header
+      headers = Util.hash_filter(options, {
+                                            range:               'Range',
+                                            if_modified_since:   'If-Modified-Since',
+                                            if_unmodified_since: 'If-Unmodified-Since',
+                                            if_match:            'If-Match',
+                                            if_none_match:       'If-None-Match'
+                                        })
+
+      # request params query string
+      query_string = Util.hash_filter(options, {
+                                                 response_content_type:        'response-content-type',
+                                                 response_content_language:    'response-content-language',
+                                                 response_expires:             'response-expires',
+                                                 response_cache_control:       'response-cache-control',
+                                                 response_content_disposition: 'response-content-disposition',
+                                                 response_content_encoding:    'response-content-encoding'
+                                             })
+
+      client.get(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object}",
+          headers:      headers,
+          sign_configs: { resource: "/#{bucket_name}", sign_query_string: true },
+          query_string: query_string,
+          as:           :raw
+      )
+    end
+
+    def append_object(bucket_name, object, file, position = 0, options = {})
+      # set header
+      headers = Util.hash_filter(options, {
+                                            expires:             'Expires',
+                                            content_control:     'Cache-Control',
+                                            content_encoding:    'Content-Encoding',
+                                            content_type:        'Content-Type',
+                                            content_md5:         'Content-MD5',
+                                            content_disposition: 'Content-Disposition',
+                                            encryption:          'x-oss-server-side-encryption',
+                                            acl:                 'x-oss-object-acl',
+                                        })
+
+      # sign configs
+      sign_configs = {
+          resource:     "/#{bucket_name}",
+          content_type: options[:content_type],
+          content_md5:  options[:content_md5],
+          sign_query_string: true,
+          oss_headers:  Util.oss_headers_to_s(options, {
+                                                         acl:        'x-oss-object-acl',
+                                                         encryption: 'x-oss-server-side-encryption',
+                                                     })
+      }
+
+      resp = client.post(
+          host:         "#{bucket_name}.#{client.endpoint}",
+          path:         "/#{object}?append&position=#{position}",
+          headers:      headers,
+          sign_configs: sign_configs,
+          payload:      file,
+          as:           :raw
+      )
+
+      {
+          hash_crc64ecma:       resp.headers[:x_oss_hash_crc64ecma],
+          next_append_position: resp.headers[:x_oss_next_append_position].to_i
+      }
+    end
+
+    # params:
+    # - bucket_name
+    # - object_name
+    def delete_object(bucket_name, object_name)
+
+      client.delete(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: "/#{object_name}",
+          sign_configs: {resource: "/#{bucket_name}"}
+      )
+
+      true
+    end
+
+    def delete_multiple_objects(bucket_name, objects = [])
+      # build payload xml
+      payload = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do
+        Delete do
+          Quiet 'false'
+          objects.each do |obj|
+            Object do
+              Key obj
+            end
+          end
+        end
+      end
+
+      xml_obj = client.post(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: "/?delete",
+          sign_configs: {resource: "/#{bucket_name}", content_type: 'application/x-www-form-urlencoded'},
+          content_md5_check: true,
+          content_length_check: true,
+          payload: payload.to_xml
+      )
+
+      # parse return deleted keys
+      deleted = Array.new
+      xml_obj.xpath('DeleteResult/Deleted').each do |obj|
+        deleted << obj.xpath('Key').text
+      end
+
+      deleted
+    end
+
+    def head_object(bucket_name, object_name, options = {})
+      # set header
+      headers = Util.hash_filter(options, {
+                                            if_modified_since:   'If-Modified-Since',
+                                            if_unmodified_since: 'If-Unmodified-Since',
+                                            if_match:            'If-Match',
+                                            if_none_match:       'If-None-Match'
+                                        })
+
+      resp = client.head(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: "/#{object_name}",
+          headers: headers,
+          sign_configs: {resource: "/#{bucket_name}"},
+          as: :raw
+      )
+
+      # head request returns hole response headers
+      resp.headers
+    end
+
+    # params:
+    # - bucket_name
+    # - object_name
+    # - acl
+    def put_object_acl(bucket_name, object_name, acl)
+      # sign configs
+      sign_configs = Hash.new
+      sign_configs[:resource]     = "/#{bucket_name}"
+      sign_configs[:oss_headers]  = "x-oss-object-acl:#{acl}"
+      sign_configs[:content_type] = 'application/x-www-form-urlencoded'
+
+      @xml_obj = client.put(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: "/#{object_name}?acl",
+          headers: {'x-oss-object-acl' => acl},
+          sign_configs: sign_configs
+      )
+
+      true
+    end
+
+    # params:
+    # - bucket_name
+    # - object_name
+    def get_object_acl(bucket_name, object_name)
+      xml_obj = client.get(
+          host: "#{bucket_name}.#{client.endpoint}",
+          path: "/#{object_name}?acl",
+          sign_configs: {resource: "/#{bucket_name}"}
+      ).xpath('AccessControlPolicy')
+
+      {
+          grant: xml_obj.xpath('AccessControlList/Grant').text,
+          owner: {
+              id:           xml_obj.xpath('Owner/ID').text,
+              display_name: xml_obj.xpath('Owner/DisplayName').text
+          }
+      }
+    end
+
+    # params:
+    # - bucket_name
+    # - key
+    # - options
+    def post_object(bucket_name, key, options = {})
+
+      # build form upload info hash
+      form_hash = { 'key' => key, 'action' => "http://#{bucket_name}.#{client.endpoint}/"}
+      options.each do |k, v|
+        # need Signature
+        if k == :policy
+          # json policy string to base64 policy string
+          form_hash['policy'] = Base64.encode64(v).gsub("\n", '')
+
+          # create signature
+          digest = OpenSSL::Digest.new('sha1')
+          h = OpenSSL::HMAC.digest(digest, client.access_key_secret, form_hash['policy'])
+          # base64 result
+          form_hash['Signature'] = Base64.encode64(h).gsub("\n", '')
+          # add access key id
+          form_hash['OSSAccessKeyId'] = client.access_key_id
+        else
+          form_hash[k.to_s] = v
+        end
+      end
+
+      # return a hash for render a html upload form
+      form_hash
+    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/service.rb

@@ -0,0 +1,63 @@
+require 'oss/client'
+require 'oss/util'
+
+module Oss
+
+  SERVICE_HOST = 'oss.aliyuncs.com'
+
+  class Service
+
+    include Util
+
+    attr_accessor :client, :xml_obj
+
+    def initialize(client)
+      @client = client
+    end
+
+    # params:
+    # - options:
+    #   - prefix
+    #   - marker
+    #   - max_keys
+    def get_service(options = {})
+      @xml_obj = client.get(host: SERVICE_HOST, path: '/', query_string: options).xpath('ListAllMyBucketsResult')
+      self
+    end
+
+    def owner
+      owner = @xml_obj.xpath('Owner')
+      {
+          :id           => owner.xpath('ID').text,
+          :display_name => owner.xpath('DisplayName').text
+      }
+    end
+
+    def buckets
+      buckets = @xml_obj.xpath('Buckets')
+      results = Array.new
+      buckets.each do |bucket|
+        results << {
+            :location      => bucket.xpath('Bucket/Location').text,
+            :name          => bucket.xpath('Bucket/Name').text,
+            :creation_date => bucket.xpath('Bucket/CreationDate').text
+        }
+      end
+      results
+    end
+
+    # prefix, marker, max_keys, is_truncated, next_marker
+    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/util.rb

@@ -0,0 +1,59 @@
+module Oss
+
+  module Util extend self
+
+    def camelize(str)
+      str.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def hash_filter(input_hash, key_map, target_hash = Hash.new)
+      key_map.each do |key, value|
+        unless input_hash[key].nil?
+          target_hash[value] = input_hash[key]
+        end
+      end
+      target_hash
+    end
+
+    # x-oss:value
+    def oss_headers_to_s(input_hash, key_map)
+      header_array = Array.new
+
+      # sort by hash value
+      sorted = Hash[key_map.sort_by{|k,v| v}]
+
+      sorted.each do |key, value|
+        unless input_hash[key].nil?
+          header_array << "#{value}:#{input_hash[key]}"
+        end
+      end
+      header_array.join("\n")
+    end
+
+    def set_query_string(path, query)
+      return path if query.nil?
+
+      attrs = Array.new
+      new_path = "#{path}"
+
+      # sort by hash value
+      sorted = Hash[query.sort_by{|k,v| k}]
+
+      sorted.each do |k, v|
+        # query key ruby hash _ to -
+        attrs << "#{k.to_s.gsub('_', '-')}=#{v}"
+      end
+
+      # create http request query string
+      if attrs.length > 0
+        new_path << "?#{attrs.join('&')}"
+      end
+
+      new_path
+    end
+
+
+
+  end
+
+end

data/lib/oss/version.rb

@@ -0,0 +1,3 @@
+module Oss
+  VERSION = '0.1.1'
+end

data/oss.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oss/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "oss"
+  spec.version       = Oss::VERSION
+  spec.authors       = ["RaymondChou"]
+  spec.email         = ["freezestart@gmail.com"]
+
+  spec.summary       = %q{Aliyun OSS Ruby SDK}
+  spec.description   = %q{Aliyun OSS(Object Storage Service) Ruby SDK}
+  spec.homepage      = "http://github.com/RaymondChou"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rest-client", "~> 1.8"
+  spec.add_development_dependency "nokogiri", "~> 1.6"
+end