fog-aliyun 0.3.13 → 0.3.19

data/lib/fog/aliyun/models/storage/files.rb

@@ -20,71 +20,30 @@ module Fog
 
         model Fog::Aliyun::Storage::File
 
-        # check_directory_key have two functions:
-        # 1. trim the directory_key suffix '/'
-        # 2. checking whether the directory_key is a bucket.
-        #    If so, it will return directly to avoid to create a new redundant folder named with directory_key.
-        #    This point will be applied to multi-bucket and make bucket as a directory scenario.
-        def check_directory_key(directory_key)
-          bucket_name = nil
-          if directory_key.is_a? Array
-            directory_key = directory_key[0]
-          end
-          if directory_key != ''
-            # trim the suffix '/'
-            directory_key = directory_key.chomp('/')
-            # The bucket name can not contain '/', so if directory_key, return directory.
-            if directory_key.include? '/'
-              directory_key
-            else
-              data = service.get_bucket(directory_key)
-              if data.class == Hash && data.key?('Code') && !data['Code'].nil? && !data['Code'].empty?
-                directory_key
-              else
-                bucket_name = directory_key
-                directory_key = ''
-              end
-            end
-          end
-          return bucket_name, directory_key
-        end
-
         def all(options = {})
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          remap_attributes(options, {
-              :delimiter  => 'delimiter',
-              :marker     => 'marker',
-              :max_keys   => 'max-keys',
-              :prefix     => 'prefix'
-          })
-          prefix_value = options['prefix']
-          prefix_value = directory_key + '/' + prefix if directory_key != '' && directory_key != '.' && !directory_key.nil?
-          options['prefix'] = prefix_value
-          options['bucket'] = bucket_name
-          files = service.list_objects(options)['Contents']
-          return if files.nil?
-          data = []
-          i = 0
-          files.each do |file|
-            next unless file['Key'][0][-1] != '/'
-            content_length = file['Size'][0].to_i
-            key = file['Key'][0]
-            lastModified = file['LastModified'][0]
-            last_modified = (Time.parse(lastModified).localtime if !lastModified.nil? && lastModified != '')
-            type = file['Type'][0]
-            data[i] = { content_length: content_length,
-                        key: key,
-                        last_modified: last_modified,
-                        etag: file['ETag'][0],
-                        object_type: type }
-            i += 1
+          options = {
+              'delimiter': delimiter,
+              'marker': marker,
+              'max-keys': max_keys.to_i,
+              'prefix': prefix
+          }.merge!(options)
+          options = options.reject {|key,value| value.nil? || value.to_s.empty?}
+          merge_attributes(options)
+          parent = directory.collection.get(
+              directory.key,
+              options
+          )
+          if parent
+            merge_attributes(parent.files.attributes)
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
           end
-
-          load(data)
         end
 
-        alias each_file_this_page each
+        alias_method :each_file_this_page, :each
+
         def each
           if !block_given?
             self
@@ -92,7 +51,7 @@ module Fog
             subset = dup.all
 
             subset.each_file_this_page { |f| yield f }
-            while subset.length == (subset.limit || 10_000)
+            while subset.is_truncated
               subset = subset.all(marker: subset.last.key)
               subset.each_file_this_page { |f| yield f }
             end
@@ -101,124 +60,71 @@ module Fog
           end
         end
 
-        def get(key)
+        def get(key, options = {}, &block)
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          object = if directory_key == ''
-                     key
-                   else
-                     directory_key + '/' + key
-                   end
           begin
-            data = service.get_object(object, nil, bucket: bucket_name)
-            lastModified = data['headers'][:last_modified]
-            last_modified = (Time.parse(lastModified).localtime if !lastModified.nil? && lastModified != '')
-
-            date = data['headers'][:date]
-            date = (Time.parse(date).localtime if !date.nil? && date != '')
-            file_data = {
-                body: data[:body],
-                content_length: data['headers'][:content_length].to_i,
-                key: key,
-                last_modified: last_modified,
-                content_type: data['headers'][:content_type],
-                etag: data['headers'][:etag],
-                date: date,
-                connection: data['headers'][:connection],
-                accept_ranges: data['headers'][:accept_ranges],
-                server: data['headers'][:server],
-                object_type: data['headers'][:x_oss_object_type]
-            }
-
+            data = service.get_object(directory.key, key, options, &block)
+            normalize_headers(data)
+            file_data = data.headers.merge({
+                                               :body => data.body,
+                                               :key  => key
+                                           })
             new(file_data)
-          rescue AliyunOssSdk::ServerError => error
-            case error.error_code
-            when %r{NoSuchKey},%r{SymlinkTargetNotExist}
-              nil
-            else
-              raise(error)
+          rescue Exception => error
+            case error.http_code.to_i
+              when 404
+                nil
+              else
+                raise(error)
             end
           end
         end
 
-        def get_url(key)
+        # @param options[Hash] No need to use
+        def get_url(key, options = {})
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          object = if directory_key == ''
-                     key
-                   else
-                     directory_key + '/' + key
-                   end
-          service.get_object_http_url_public(object, 3600, bucket: bucket_name)
+          service.get_object_http_url_public(directory.key, key, 3600)
         end
 
+        # @param options[Hash] No need to use
         def get_http_url(key, expires, options = {})
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          object = if directory_key == ''
-                     key
-                   else
-                     directory_key + '/' + key
-                   end
-          expires = expires.nil? ? 0 : expires.to_i
-          service.get_object_http_url_public(object, expires, options.merge(bucket: bucket_name))
+          service.get_object_http_url_public(directory.key, key, expires)
         end
 
+        # @param options[Hash] No need to use
         def get_https_url(key, expires, options = {})
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          object = if directory_key == ''
-                     key
-                   else
-                     directory_key + '/' + key
-                   end
-          expires = expires.nil? ? 0 : expires.to_i
-          service.get_object_https_url_public(object, expires, options.merge(bucket: bucket_name))
+          service.get_object_https_url_public(directory.key, key, expires)
         end
 
-        def head(key, _options = {})
+        def head(key, options = {})
           requires :directory
-          bucket_name, directory_key = check_directory_key(directory.key)
-          object = if directory_key == ''
-                     key
-                   else
-                     directory_key + '/' + key
-                   end
-          data = service.head_object(object, bucket: bucket_name).data
-          return nil if data[:status] == 404
-          lastModified = data[:headers]['Last-Modified']
-          last_modified = (Time.parse(lastModified).localtime if !lastModified.nil? && lastModified != '')
-
-          date = data[:headers]['Date']
-          date = (Time.parse(date).localtime if !date.nil? && date != '')
-
-          file_data = {
-            content_length: data[:headers]['Content-Length'].to_i,
-            key: key,
-            last_modified: last_modified,
-            content_type: data[:headers]['Content-Type'],
-            etag: data[:headers]['ETag'],
-            date: date,
-            connection: data[:headers]['Connection'],
-            accept_ranges: data[:headers]['Accept-Ranges'],
-            server: data[:headers]['Server'],
-            object_type: data[:headers]['x-oss-object-type']
-          }
-          new(file_data)
-        rescue Fog::Aliyun::Storage::NotFound
-          nil
+          begin
+            data = service.head_object(directory.key, key, options)
+            normalize_headers(data)
+            file_data = data.headers.merge({
+                                               :key => key
+                                           })
+            new(file_data)
+          rescue Exception => error
+            case error.http_code.to_i
+              when 404
+                nil
+              else
+                raise(error)
+            end
+          end
         end
 
         def new(attributes = {})
           requires :directory
-          # Sometimes, the v will be a Array, like "Prefix"=>[{}], "Marker"=>[xxxx], "MaxKeys"=>["100"], "IsTruncated"=>["false"]
-          # and there needs to parse them
-          for k, v in attributes
-            if !v.nil? && (v.is_a? Array) && (v.size > 0)
-              attributes[k] = v[0]
-            end
-          end
-          super({ directory: directory }.merge!(attributes))
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+        def normalize_headers(data)
+          data.headers[:last_modified] = Time.parse(data.headers[:last_modified])
+          data.headers[:etag] = data.headers[:etag].gsub('"','')
         end
       end
     end

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

@@ -0,0 +1,22 @@
+
+module Fog
+  module Aliyun
+    class Storage
+      class Real
+        #
+        # Abort a multipart upload
+        #
+        # @param [String] bucket_name Name of bucket to abort multipart upload on
+        # @param [String] object_name Name of object to abort multipart upload on
+        # @param [String] upload_id Id of upload to add part to
+        #
+        # @see https://help.aliyun.com/document_detail/31996.html
+        #
+        def abort_multipart_upload(bucket_name, object_name, upload_id)
+          @oss_protocol.abort_multipart_upload(bucket_name, object_name, upload_id)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+
+module Fog
+  module Aliyun
+    class Storage
+      class Real
+        # Complete a multipart upload
+        #
+        # @param [String] bucket_name Name of bucket to complete multipart upload for
+        # @param [String] object_name Name of object to complete multipart upload for
+        # @param [String] upload_id Id of upload to add part to
+        # @param [Array] parts Array of etag and number as Strings for parts
+        #
+        # @see https://help.aliyun.com/document_detail/31995.html
+        #
+        def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+          @oss_protocol.complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+        end
+      end
+    end
+  end
+end

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

@@ -7,26 +7,21 @@ module Fog
         # Copy object
         #
         # ==== Parameters
-        # * source_bucket<~String> - Name of source bucket
-        # * source_object<~String> - Name of source object
-        # * target_bucket<~String> - Name of bucket to create copy in
-        # * target_object<~String> - Name for new copy of object
+        # * source_bucket_name<~String> - Name of source bucket
+        # * source_object_name<~String> - Name of source object
+        # * target_bucket_name<~String> - Name of bucket to create copy in
+        # * target_object_name<~String> - Name for new copy of object
         # * options<~Hash> - Additional headers options={}
-        def copy_object(source_bucket, source_object, target_bucket, target_object, options = {})
-          options = options.reject { |_key, value| value.nil? }
-          bucket = options[:bucket]
-          bucket ||= @aliyun_oss_bucket
-          source_bucket ||= bucket
-          target_bucket ||= bucket
-          headers = { 'x-oss-copy-source' => "/#{source_bucket}/#{source_object}" }
-          resource = target_bucket + '/' + target_object
-          request(expects: [200, 203],
-                  headers: headers,
-                  method: 'PUT',
-                  path: target_object,
-                  bucket: target_bucket,
-                  resource: resource,
-                  location: get_bucket_location(bucket))
+        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
+          headers = { 'x-oss-copy-source' => "/#{source_bucket_name}#{object_to_path(source_object_name)}" }.merge!(options)
+          resources = {
+              :bucket => target_bucket_name,
+              :object => target_object_name
+          }
+          http_options = {
+              :headers => headers
+          }
+          @oss_http.put(resources, http_options)
         end
       end
     end

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

@@ -7,17 +7,10 @@ module Fog
         # Delete an existing bucket
         #
         # ==== Parameters
-        # * bucket<~String> - Name of bucket to delete
+        # * bucket_name<~String> - Name of bucket to delete
         #
-        def delete_bucket(bucket)
-          resource = bucket + '/'
-          request(
-            expects: 204,
-            method: 'DELETE',
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
+        def delete_bucket(bucket_name)
+          @oss_protocol.delete_bucket(bucket_name)
         end
       end
     end

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

@@ -0,0 +1,20 @@
+module Fog
+  module Aliyun
+    class Storage
+      class Real
+
+        # Delete multiple objects from OSS
+        #
+        # @param bucket_name [String] Name of bucket containing object to delete
+        # @param object_names [Array]  Array of object names to delete
+        #
+        # @see https://help.aliyun.com/document_detail/31983.html
+
+        def delete_multiple_objects(bucket_name, object_names, options = {})
+          bucket = @oss_client.get_bucket(bucket_name)
+          bucket.batch_delete_objects(object_names, options)
+        end
+      end
+    end
+  end
+end

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

@@ -7,18 +7,17 @@ module Fog
         # Delete an existing object
         #
         # ==== Parameters
-        # * object<~String> - Name of object to delete
+        # * bucket_name<~String> - Name of bucket to delete
+        # * object_name<~String> - Name of object to delete
         #
-        def delete_object(object, options = {})
-          bucket_name = options[:bucket]
-          bucket_name ||= @aliyun_oss_bucket
-          bucket = @oss_client.get_bucket(bucket_name)
-          bucket.delete_object(object)
-        end
-
-        def abort_multipart_upload(bucket_name, object, upload_id)
-          bucket = @oss_client.get_bucket(bucket_name)
-          bucket.abort_upload(upload_id, object)
+        def delete_object(bucket_name, object_name, options = {})
+          # TODO Support versionId
+          # if version_id = options.delete('versionId')
+          #   query = {'versionId' => version_id}
+          # else
+          #   query = {}
+          # end
+          @oss_http.delete({:bucket => bucket_name, :object => object_name}, {:headers => options})
         end
       end
     end

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

@@ -4,147 +4,48 @@ module Fog
   module Aliyun
     class Storage
       class Real
-        def get_bucket(bucket, options = {})
-          prefix = options['prefix']
-          marker = options['marker']
-          # Set the GetBucket max limitation to 1000
-          maxKeys = options['max-keys'] || 1000
-          maxKeys = [maxKeys, 1000].min
-          delimiter = options['delimiter']
-          path = ''
-          if prefix
-            path += '/?prefix=' + prefix
-            path += '&marker=' + marker if marker
-            path += '&max-keys=' + maxKeys.to_s if maxKeys
-            path += '&delimiter=' + delimiter if delimiter
-
-          elsif marker
-            path += '/?marker=' + marker
-            path += '&max-keys=' + maxKeys.to_s if maxKeys
-            path += '&delimiter=' + delimiter if delimiter
+        def bucket_exists?(bucket_name)
+          @oss_client.bucket_exists?(bucket_name)
+        end
 
-          elsif maxKeys
-            path += '/?max-keys=' + maxKeys.to_s
-            path += '&delimiter=' + delimiter if delimiter
-          elsif delimiter
-            path += '/?delimiter=' + delimiter
+        def get_bucket(bucket_name, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
           end
 
-          resource = bucket + '/'
-          ret = request(
-            expects: [200, 203, 404],
-            method: 'GET',
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket),
-            path: path
-          )
-          xml = ret.data[:body]
-          XmlSimple.xml_in(xml)
-        end
+          # Set the GetBucket max limitation to 1000
+          maxKeys = options[:max_keys] || 1000
+          maxKeys = maxKeys.to_i
+          maxKeys = [maxKeys, 1000].min
 
-        def get_bucket_location(bucket)
-          attribute = '?location'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203, 403, 404],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource
-          )
-          # If there is an error, it will return a Hash with error code, host id and others
-          # If can not get a valid location, will return one using region
-          location = XmlSimple.xml_in(ret.data[:body])
-          if location.class == Hash && location.key?('HostId')
-            value = location['HostId']
-            location = value[0].split('.')[1]
-          end
-          location ||= 'oss-' + @aliyun_region_id
+          options[:limit] = maxKeys
+          options.delete(:max_keys)
+
+          @oss_protocol.list_objects(bucket_name, options)
         end
 
-        def get_bucket_acl(bucket)
-          attribute = '?acl'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body])['AccessControlList'][0]['Grant'][0]
+        def get_bucket_acl(bucket_name)
+          @oss_protocol.get_bucket_acl(bucket_name)
         end
 
-        def get_bucket_CORSRules(bucket)
-          attribute = '?cors'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203, 404],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body])['CORSRule'][0] if ret.data[:status] != 404
+        def get_bucket_CORSRules(bucket_name)
+          @oss_protocol.get_bucket_cors(bucket_name)
         end
 
-        def get_bucket_lifecycle(bucket)
-          attribute = '?lifecycle'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203, 404],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body])['Rule'][0] if ret.data[:status] != 404
+        def get_bucket_lifecycle(bucket_name)
+          @oss_protocol.get_bucket_lifecycle(bucket_name)
         end
 
-        def get_bucket_logging(bucket)
-          attribute = '?logging'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body])['LoggingEnabled'][0]['TargetPrefix']
+        def get_bucket_logging(bucket_name)
+          @oss_protocol.get_bucket_logging(bucket_name)
         end
 
-        def get_bucket_referer(bucket)
-          attribute = '?referer'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body])
+        def get_bucket_referer(bucket_name)
+          @oss_protocol.get_bucket_referer(bucket_name)
         end
 
-        def get_bucket_website(bucket)
-          attribute = '?website'
-          resource = bucket + '/' + attribute
-          ret = request(
-            expects: [200, 203, 404],
-            method: 'GET',
-            path: attribute,
-            bucket: bucket,
-            resource: resource,
-            location: get_bucket_location(bucket)
-          )
-          XmlSimple.xml_in(ret.data[:body]) if ret.data[:status] != 404
+        def get_bucket_website(bucket_name)
+          @oss_protocol.get_bucket_website(bucket_name)
         end
       end
     end