Reconstruct fog-aliyun by using oss (#147)

* reconstruct the directories

* reconstruct the directory

* reconstruct the files

* reconstruct parts of file

* reconstruct parts two of file

* reconstruct case test

* reconstruct cover case test

* reconstruct perform test

Co-authored-by: zjd <1418408614@qq.com>

Author: xiaozhu36

lib/fog/aliyun/models/storage/directories.rb

@@ -10,81 +10,47 @@ class Directories < Fog::Collection
         model Fog::Aliyun::Storage::Directory
 
         def all
-          containers = service.get_containers
-          return nil if containers.nil?
+          buckets = service.get_service[0]
+          return nil if buckets.size < 1
           data = []
           i = 0
-          containers.each do |entry|
-            key = entry['Prefix'][0]
-            key[-1] = ''
-            data[i] = { key: key }
+          buckets.each do |b|
+            data[i] = { key: b.name }
             i += 1
           end
-
           load(data)
         end
 
-        # get method used to get a specified directory.
-        # If the directory is not exist, this method will create a new with 'key'
-        # In order to support multi-buckets scenario which making bucket as a solo directory, it have been expanded.
-        # If key is a directory(including /), return an existed or a new one;
-        # If key does not contain /, if bucket, return '', else return an existed or a new one directory;
+
         def get(key, options = {})
-          if key.is_a? Array
-            key = key[0]
+          data = service.get_bucket(key, options)
+
+          directory = new(:key => key, :is_persisted => true)
+
+          options = data[1]
+          options[:max_keys] = options[:limit]
+          directory.files.merge_attributes(options)
+
+          objects = []
+          i = 0
+          data[0].each do |o|
+            objects[i] = {
+                'Key' => o.key,
+                'Type' => o.type,
+                'Size' => o.size,
+                'ETag' => o.etag,
+                'LastModified' => o.last_modified
+            }
+            i += 1
           end
-          if !key.nil? && key != '' && key != '.'
-            key = key.chomp('/')
-            if key.include? '/'
-              dir = key + '/'
-              begin
-                ret = service.head_object(dir, options)
-                new(key: key) if ret.data.code.to_i == 200
-              rescue Exception => error
-                case error.http_code.to_i
-                  when 404
-                    nil
-                  else
-                    raise(error)
-                end
-              end
-            else
-              remap_attributes(options, {
-                  :delimiter  => 'delimiter',
-                  :marker     => 'marker',
-                  :max_keys   => 'max-keys',
-                  :prefix     => 'prefix'
-              })
-              data = service.get_bucket(key, options)
-              directory = new(:key => data['Name'], :is_persisted => true)
-              options = {}
-              for k, v in data
-                if ['CommonPrefixes', 'Delimiter', 'IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(k)
-                  # Sometimes, the v will be a Array, like "Name"=>["blobstore-droplet1"], "Prefix"=>[{}], "Marker"=>[{}], "MaxKeys"=>["100"], "Delimiter"=>[{}], "IsTruncated"=>["false"]
-                  # and there needs to parse them
-                  if !v.nil? && (v.is_a? Array) && (v.size > 0)
-                    if v[0].is_a? Hash
-                      v = nil
-                    else
-                      v = v[0]
-                    end
-                  end
-                  options[k] = v
-                end
-              end
-              directory.files.merge_attributes(options)
-              if data.key?('Contents') && !data['Contents'].nil?
-                directory.files.load(data['Contents'])
-              else
-                directory.files.load([])
-              end
-              directory
-            end
+          directory.files.load(objects)
+          directory
+        rescue AliyunOssSdk::ServerError => error
+          if error.error_code == "NoSuchBucket"
+            nil
           else
-            new(key: '')
+            raise(error)
           end
-        rescue Fog::Aliyun::Storage::NotFound
-          nil
         end
       end
     end

lib/fog/aliyun/models/storage/directory.rb

@@ -7,24 +7,62 @@ module Fog
   module Aliyun
     class Storage
       class Directory < Fog::Model
+        VALID_ACLS = ['private', 'public-read', 'public-read-write']
+
+        attr_reader :acl
         identity :key, :aliases => ['Key', 'Name', 'name']
 
+        attribute :creation_date, :aliases => 'CreationDate', :type => 'time'
+
+        def acl=(new_acl)
+          unless VALID_ACLS.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{VALID_ACLS.join(', ')}]")
+          else
+            @acl = new_acl
+          end
+        end
+
         def destroy
           requires :key
-          prefix = key + '/'
-          ret = service.list_objects(prefix: prefix)['Contents']
-
-          if ret.nil?
+          service.delete_bucket(key)
+          true
+        rescue AliyunOssSdk::ServerError => error
+          if error.error_code == "NoSuchBucket"
             false
-          elsif ret.size == 1
-            service.delete_container(key)
-            true
           else
-            raise Fog::Aliyun::Storage::Error, ' Forbidden: Direction not empty!'
+            raise(error)
+          end
+        end
+
+        def destroy!(options = {})
+          requires :key
+          options = {
+              timeout: Fog.timeout,
+              interval: Fog.interval,
+          }.merge(options)
+
+          begin
+            clear!
+            Fog.wait_for(options[:timeout], options[:interval]) { objects_keys.size == 0 }
+            service.delete_bucket(key)
+            true
+          rescue AliyunOssSdk::ServerError
             false
           end
         end
 
+        def location
+          region = @aliyun_region_id
+          region ||= Storage::DEFAULT_REGION
+          @location = (bucket_location || 'oss-' + region)
+        end
+
+        # NOTE: you can't change the region once the bucket is created
+        def location=(new_location)
+          new_location = 'oss-' + new_location unless new_location.start_with?('oss-')
+          @location = new_location
+        end
+
         def files
           @files ||= begin
             Fog::Aliyun::Storage::Files.new(
@@ -34,25 +72,66 @@ def files
           end
         end
 
+        # TODO
+        def public=(new_public)
+          nil
+        end
+
+        # TODO
         def public_url
           nil
         end
 
         def save
           requires :key
 
-          # Checking whether the key is a bucket and meet the multi-bucket scenario.
-          # If the key is a existing bucket, return it directly.
-          key = key.chomp('/')
-          if !key.nil? && key != '' && key != '.' && !(key.include? '/')
-            data = service.get_bucket(key)
-            if data.class == Hash && data.key?('Code') && !data['Code'].nil? && !data['Code'].empty?
-              service.put_container(key)
-            end
-          end
+          options = {}
+
+          options['x-oss-acl'] = acl if acl
+
+          # https://help.aliyun.com/document_detail/31959.html
+          # if !persisted?
+          #   # There is a sdk bug that location can not be set
+          #   options[:location] = location
+          # end
+
+          service.put_bucket(key, options)
+          attributes[:is_persisted] = true
 
           true
         end
+
+        def persisted?
+          # is_persisted is true in case of directories.get or after #save
+          # creation_date is set in case of directories.all
+          attributes[:is_persisted] || !!attributes[:creation_date]
+        end
+
+        private
+
+        def bucket_location
+          requires :key
+          return nil unless persisted?
+          service.get_bucket_location(key)
+        end
+
+        def objects_keys
+          requires :key
+          bucket_query = service.get_bucket(key)
+
+          object_keys = []
+          i = 0
+          bucket_query[0].each do |o|
+            object_keys[i] = o.key
+            i += 1
+          end
+          object_keys
+        end
+
+        def clear!
+          requires :key
+          service.delete_multiple_objects(key, objects_keys) if objects_keys.size > 0
+        end
       end
     end
   end