fog-xiaozhu 0.2.1

data/lib/fog/aliyun/requests/storage/list_buckets.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Storage
+    class Aliyun
+      class Real
+        def list_buckets(options = {})
+          prefix = options[:prefix]
+          marker = options[:marker]
+          maxKeys = options[:maxKeys]
+
+          path = ''
+          if prefix
+            path += '?prefix=' + prefix
+            path += '&marker=' + marker if marker
+            path += '&max-keys=' + maxKeys if maxKeys
+
+          elsif marker
+            path += '?marker=' + marker
+            path += '&max-keys=' + maxKeys if maxKeys
+
+          elsif maxKeys
+            path += '?max-keys=' + maxKeys
+          end
+
+          ret = request(
+            expects: [200, 203],
+            method: 'GET',
+            path: path
+          )
+          xml = ret.data[:body]
+          result = XmlSimple.xml_in(xml)['Buckets'][0]
+        end
+      end
+
+      class Mock
+        def list_buckets(options = {})
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/requests/storage/list_objects.rb

@@ -0,0 +1,91 @@
+module Fog
+  module Storage
+    class Aliyun
+      class Real
+        def list_objects(options = {})
+          bucket = options[:bucket]
+          bucket ||= @aliyun_oss_bucket
+          prefix = options[:prefix]
+          marker = options[:marker]
+          maxKeys = options[:maxKeys]
+          delimiter = options[:delimiter]
+
+          path = ''
+          if prefix
+            path += '?prefix=' + prefix
+            path += '&marker=' + marker if marker
+            path += '&max-keys=' + maxKeys if maxKeys
+            path += '&delimiter=' + delimiter if delimiter
+
+          elsif marker
+            path += '?marker=' + marker
+            path += '&max-keys=' + maxKeys if maxKeys
+            path += '&delimiter=' + delimiter if delimiter
+
+          elsif maxKeys
+            path += '?max-keys=' + maxKeys
+            path += '&delimiter=' + delimiter if delimiter
+          elsif delimiter
+            path += '?delimiter=' + delimiter
+          end
+
+          location = get_bucket_location(bucket)
+          endpoint = 'http://' + location + '.aliyuncs.com'
+          resource = bucket + '/'
+          ret = request(
+            expects: [200, 203, 400],
+            method: 'GET',
+            path: path,
+            resource: resource,
+            bucket: bucket
+          )
+          xml = ret.data[:body]
+          result = XmlSimple.xml_in(xml)
+        end
+
+        def list_multipart_uploads(bucket, endpoint, _options = {})
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          path = '?uploads'
+          resource = bucket + '/' + path
+
+          ret = request(
+            expects: 200,
+            method: 'GET',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint
+          )
+          uploadid = XmlSimple.xml_in(ret.data[:body])['Upload']
+        end
+
+        def list_parts(bucket, object, endpoint, uploadid, _options = {})
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          path = object + '?uploadId=' + uploadid
+          resource = bucket + '/' + path
+
+          ret = request(
+            expects: 200,
+            method: 'GET',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint
+          )
+          parts = XmlSimple.xml_in(ret.data[:body])['Part']
+        end
+      end
+
+      class Mock
+        def list_objects(options = {})
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/requests/storage/put_bucket.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Storage
+    class Aliyun
+      class Real
+        def put_bucket(bucketName)
+          resource = bucketName + '/'
+          ret = request(
+            expects: [200, 203],
+            method: 'PUT',
+            resource: resource,
+            bucket: bucketName
+          )
+        end
+      end
+
+      class Mock
+        def put_bucket(bucketName)
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/requests/storage/put_container.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Storage
+    class Aliyun
+      class Real
+        # Create a new container
+        #
+        # ==== Parameters
+        # * name<~String> - Name for container
+        #
+        def put_container(name, options = {})
+          bucket = options[:bucket]
+          bucket ||= @aliyun_oss_bucket
+          location = get_bucket_location(bucket)
+          endpoint = 'http://' + location + '.aliyuncs.com'
+
+          path = name + '/'
+          resource = bucket + '/' + name + '/'
+          request(
+            expects: [200, 203],
+            method: 'PUT',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint
+          )
+        end
+      end
+
+      class Mock
+        def put_container(name, options = {})
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/requests/storage/put_object.rb

@@ -0,0 +1,189 @@
+module Fog
+  module Storage
+    class Aliyun
+      class Real
+        # Put details for object
+        #
+        # ==== Parameters
+        # * object<~String> - Name of object to look for
+        #
+        def put_object(object, file = nil, options = {})
+          bucket = options[:bucket]
+          bucket ||= @aliyun_oss_bucket
+          location = get_bucket_location(bucket)
+          endpoint = 'http://' + location + '.aliyuncs.com'
+          return put_folder(bucket, object, endpoint) if nil == file
+
+          # put multiparts if object's size is over 100m
+          if file.size > 104_857_600
+            return put_multipart_object(bucket, object, file)
+          end
+
+          body = file.read
+
+          resource = bucket + '/' + object
+          ret = request(
+            expects: [200, 203],
+            method: 'PUT',
+            path: object,
+            bucket: bucket,
+            resource: resource,
+            body: body,
+            endpoint: endpoint
+          )
+        end
+
+        def put_object_with_body(object, body, options = {})
+          bucket = options[:bucket]
+          bucket ||= @aliyun_oss_bucket
+          location = get_bucket_location(bucket)
+          endpoint = 'http://' + location + '.aliyuncs.com'
+
+          resource = bucket + '/' + object
+          ret = request(
+            expects: [200, 203],
+            method: 'PUT',
+            path: object,
+            bucket: bucket,
+            resource: resource,
+            body: body,
+            endpoint: endpoint
+          )
+      end
+
+        def put_folder(bucket, folder, endpoint)
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          path = folder + '/'
+          resource = bucket + '/' + folder + '/'
+          ret = request(
+            expects: [200, 203],
+            method: 'PUT',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint
+          )
+        end
+
+        def put_multipart_object(bucket, object, file)
+          location = get_bucket_location(bucket)
+          endpoint = 'http://' + location + '.aliyuncs.com'
+
+          # find the right uploadid
+          uploads = list_multipart_uploads(bucket, endpoint)
+          if nil != uploads
+            upload = uploads.find { |tmpupload| tmpupload['Key'][0] == object }
+          else
+            upload = nil
+          end
+
+          parts = nil
+          uploadedSize = 0
+          start_partNumber = 1
+          if nil != upload
+            uploadId = upload['UploadId'][0]
+            parts = list_parts(bucket, object, endpoint, uploadId)
+            if (nil != parts) && !parts.empty?
+              if parts[-1]['Size'][0].to_i != 5_242_880
+                # the part is the last one, if its size is over 5m, then finish this upload
+                complete_multipart_upload(bucket, object, endpoint, uploadId)
+                return
+              end
+              uploadedSize = (parts[0]['Size'][0].to_i * (parts.size - 1)) + parts[-1]['Size'][0].to_i
+              start_partNumber = parts[-1]['PartNumber'][0].to_i + 1
+            end
+          else
+            # create upload ID
+            uploadId = initiate_multipart_upload(bucket, object, endpoint)
+          end
+
+          if file.size <= uploadedSize
+            complete_multipart_upload(bucket, object, endpoint, uploadId)
+            return
+          end
+
+          end_partNumber = (file.size + 5_242_880 - 1) / 5_242_880
+          file.seek(uploadedSize)
+
+          for i in start_partNumber..end_partNumber
+            body = file.read(5_242_880)
+            upload_part(bucket, object, endpoint, i.to_s, uploadId, body)
+          end
+
+          complete_multipart_upload(bucket, object, endpoint, uploadId)
+        end
+
+        def initiate_multipart_upload(bucket, object, endpoint)
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          path = object + '?uploads'
+          resource = bucket + '/' + path
+          ret = request(
+            expects: 200,
+            method: 'POST',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint
+          )
+          uploadid = XmlSimple.xml_in(ret.data[:body])['UploadId'][0]
+        end
+
+        def upload_part(bucket, object, endpoint, partNumber, uploadId, body)
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          path = object + '?partNumber=' + partNumber + '&uploadId=' + uploadId
+          resource = bucket + '/' + path
+          ret = request(
+            expects: [200, 203],
+            method: 'PUT',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            body: body,
+            endpoint: endpoint
+          )
+        end
+
+        def complete_multipart_upload(bucket, object, endpoint, uploadId)
+          if nil == endpoint
+            location = get_bucket_location(bucket)
+            endpoint = 'http://' + location + '.aliyuncs.com'
+          end
+          parts = list_parts(bucket, object, endpoint, uploadId, options = {})
+          request_part = []
+          return if parts.empty?
+          for i in 0..(parts.size - 1)
+            part = parts[i]
+            request_part[i] = { 'PartNumber' => part['PartNumber'], 'ETag' => part['ETag'] }
+          end
+          body = XmlSimple.xml_out({ 'Part' => request_part }, 'RootName' => 'CompleteMultipartUpload')
+
+          path = object + '?uploadId=' + uploadId
+          resource = bucket + '/' + path
+          ret = request(
+            expects: 200,
+            method: 'POST',
+            path: path,
+            bucket: bucket,
+            resource: resource,
+            endpoint: endpoint,
+            body: body
+          )
+        end
+      end
+
+      class Mock
+        def put_object(object, file = nil, options = {})
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/storage.rb

@@ -0,0 +1,233 @@
+require 'xmlsimple'
+
+module Fog
+  module Storage
+    class Aliyun < Fog::Service
+
+      DEFAULT_REGION = 'cn-hangzhou'
+
+      DEFAULT_SCHEME = 'http'
+      DEFAULT_SCHEME_PORT = {
+          'http' => 80,
+          'https' => 443
+      }
+
+      recognizes :aliyun_oss_endpoint,
+                 :aliyun_oss_location,
+                 :aliyun_region_id
+      requires   :aliyun_accesskey_id,
+                 :aliyun_accesskey_secret,
+                 :aliyun_oss_bucket
+
+      model_path 'fog/aliyun/models/storage'
+      model       :directory
+      collection  :directories
+      model       :file
+      collection  :files
+
+      request_path 'fog/aliyun/requests/storage'
+      request :copy_object
+      request :delete_bucket
+      request :delete_object
+      request :get_bucket
+      request :get_object
+      request :get_object_http_url
+      request :get_object_https_url
+      request :head_object
+      request :put_bucket
+      request :put_object
+      request :list_buckets
+      request :list_objects
+      request :get_containers
+      request :get_container
+      request :delete_container
+      request :put_container
+
+      class Real
+        # Initialize connection to OSS
+        #
+        # ==== Notes
+        # options parameter must include values for :aliyun_accesskey_id, :aliyun_secret_access_key and :aliyun_oss_bucket in order to create a connection.
+        # :aliyun_oss_location will be replaced by :aliyun_region_id, and it has a default value cn-hangzhou
+        # if :aliyun_oss_endpoint is not specified, it will be generated by method region_to_endpoint
+        #
+        # ==== Examples
+        #   sdb = Fog::Storage.new(:provider=>'aliyun',
+        #    :aliyun_accesskey_id => your_:aliyun_accesskey_id,
+        #    :aliyun_secret_access_key => your_aliyun_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * OSS object with connection to aliyun.
+        attr_reader :aliyun_accesskey_id
+        attr_reader :aliyun_accesskey_secret
+        attr_reader :aliyun_oss_endpoint
+        attr_reader :aliyun_region_id
+        attr_reader :aliyun_oss_bucket
+
+        def initialize(options = {})
+          # initialize the parameters
+          @aliyun_region_id        = options[:aliyun_region_id] || options[:aliyun_oss_location] || DEFAULT_REGION
+          @aliyun_oss_endpoint     = options[:aliyun_oss_endpoint] || region_to_endpoint(@aliyun_region_id)
+          @aliyun_accesskey_id     = options[:aliyun_accesskey_id]
+          @aliyun_accesskey_secret = options[:aliyun_accesskey_secret]
+          @aliyun_oss_bucket       = options[:aliyun_oss_bucket]
+
+          # check for the parameters
+          missing_credentials = []
+          missing_credentials << :aliyun_oss_bucket unless @aliyun_oss_bucket
+          missing_credentials << :aliyun_accesskey_id unless @aliyun_accesskey_id
+          missing_credentials << :aliyun_accesskey_secret unless @aliyun_accesskey_secret
+          raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+
+          @connection_options = options[:connection_options] || {}
+
+          endpoint = @aliyun_oss_endpoint
+
+          if !endpoint.start_with?(DEFAULT_SCHEME)
+            @aliyun_oss_endpoint = "#{DEFAULT_SCHEME}://#{endpoint}"
+          end
+
+          uri = URI.parse(@aliyun_oss_endpoint)
+          @host   = uri.host
+          @path   = uri.path
+          @scheme = uri.scheme || DEFAULT_SCHEME
+          @port   = uri.port || DEFAULT_SCHEME_PORT[@scheme]
+
+          @persistent = options[:persistent] || false
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def region_to_endpoint(region=nil)
+          case region.to_s
+            when ''
+              "oss-#{DEFAULT_REGION}.aliyuncs.com"
+            else
+              "oss-#{region}.aliyuncs.com"
+          end
+        end
+
+        def request(params)
+          method = params[:method]
+          time = Time.new.utc
+          date = time.strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+          endpoint = params[:endpoint]
+          if endpoint
+            uri = URI.parse(endpoint)
+            host   = uri.host
+            path   = uri.path
+            port   = uri.port
+            scheme = uri.scheme
+          else
+            host   = @host
+            path   = @path
+            port   = @port
+            scheme = @scheme
+          end
+
+          bucket = params[:bucket]
+          tmpHost = if bucket
+                      bucket + '.' + host
+                    else
+                      host
+                    end
+
+          @connection = Fog::Core::Connection.new("#{scheme}://#{tmpHost}", @persistent, @connection_options)
+          contentType = params[:contentType]
+
+          begin
+            headers = ''
+            if params[:headers]
+              params[:headers].each do |k, v|
+                headers += "#{k}:#{v}\n" if k != 'Range'
+              end
+            end
+            signature = sign(method, date, contentType, params[:resource], headers)
+            response = @connection.request(params.merge(headers: {
+              'Content-Type' => contentType,
+              'Authorization' => 'OSS ' + @aliyun_accesskey_id + ':' + signature,
+              'Date' => date
+            }.merge!(params[:headers] || {}),
+                                                        path: "#{path}/#{params[:path]}",
+                                                        query: params[:query]))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+                  when Excon::Errors::NotFound
+                    Fog::Storage::Aliyun::NotFound.slurp(error)
+                  else
+                    error
+              end
+          end
+
+          response
+        end
+
+        # copmute signature
+        def sign(method, date, contentType, resource = nil, headers = nil)
+          contentmd5 = ''
+
+          canonicalizedResource = if resource
+                                    '/' + resource
+                                  else
+                                    '/'
+                                  end
+
+          canonicalizedOSSHeaders = if headers
+                                      headers
+                                    else
+                                      ''
+                                    end
+
+          contentTypeStr = if contentType
+                             contentType
+                           else
+                             ''
+                           end
+
+          stringToSign = method + "\n" + contentmd5 + "\n" + contentTypeStr + "\n" + date + "\n" + canonicalizedOSSHeaders + canonicalizedResource
+
+          digVer =  OpenSSL::Digest.new('sha1')
+          digest =  OpenSSL::HMAC.digest(digVer, @aliyun_accesskey_secret, stringToSign)
+          signature = Base64.encode64(digest)
+          signature[-1] = ''
+
+          signature
+        end
+      end
+
+      class Mock
+        def initialize(options = {})
+          @aliyun_oss_endpoint     = options[:aliyun_oss_endpoint]
+          @aliyun_region_id        = options[:aliyun_region_id]
+          @aliyun_accesskey_id     = options[:aliyun_accesskey_id]
+          @aliyun_accesskey_secret = options[:aliyun_accesskey_secret]
+          @aliyun_oss_bucket       = options[:aliyun_oss_bucket]
+
+          # missing_credentials = Array.new
+          # missing_credentials << :aliyun_oss_endpoint unless @aliyun_oss_endpoint
+          # missing_credentials << :aliyun_region_id unless @aliyun_region_id
+          # missing_credentials << :aliyun_accesskey_id  unless @aliyun_accesskey_id
+          # missing_credentials << :aliyun_accesskey_secret unless @aliyun_accesskey_secret
+          # raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+
+          @connection_options = options[:connection_options] || {}
+
+          # uri = URI.parse(@aliyun_oss_endpoint)
+          # @host   = uri.host
+          # @path   = uri.path
+          # @port   = uri.port
+          # @scheme = uri.scheme
+
+          # @persistent = options[:persistent] || false
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Aliyun
+    VERSION = '0.2.1'.freeze
+  end
+end

data/lib/fog/aliyun.rb

@@ -0,0 +1,19 @@
+require 'fog/core'
+require 'fog/json'
+require 'fog/aliyun/version'
+
+module Fog
+  module Compute
+    ret = autoload :Aliyun, 'fog/aliyun/compute'
+  end
+
+  module Storage
+    ret = autoload :Aliyun, 'fog/aliyun/storage'
+  end
+
+  module Aliyun
+    extend Fog::Provider
+    service(:compute, 'Compute')
+    service(:storage, 'Storage')
+  end
+end

data/lib/fog/bin/aliyun.rb

@@ -0,0 +1,31 @@
+class Aliyun < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :storage
+        Fog::Storage::Aliyun
+      when :compute
+        Fog::Compute::Aliyun
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+                    when :storage
+                      Fog::Logger.warning('Aliyun[:storage] is not recommended, use Storage[:openstack] for portability')
+                      Fog::Storage.new(provider: 'aliyun')
+                    else
+                      raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Aliyun.services
+    end
+  end
+end