fog-xiaozhu 0.2.1

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

@@ -0,0 +1,192 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Aliyun
+      class File < Fog::Model
+        identity  :key,                 aliases: 'name'
+        attribute :date,                aliases: 'Date'
+        attribute :content_length,      aliases: 'Content-Length', type: :integer
+        attribute :content_type,        aliases: 'Content-Type'
+        attribute :connection,          aliases: 'Connection'
+        attribute :content_disposition, aliases: 'Content-Disposition'
+        attribute :etag,                aliases: 'Etag'
+        attribute :last_modified,       aliases: 'Last-Modified', type: :time
+        attribute :accept_ranges,       aliases: 'Accept-Ranges'
+        attribute :server,              aliases: 'Server'
+        attribute :object_type,         aliases: 'x-oss-object-type'
+
+        def body
+          attributes[:body] ||= if last_modified
+                                  collection.get(identity).body
+                                else
+                                  ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        attr_reader :directory
+
+        def copy(target_directory_key, target_file_key, options = {})
+          requires :directory, :key
+          source_object = if directory.key == ''
+                            key
+                          else
+                            directory.key + '/' + key
+                          end
+          if target_directory_key == ''
+            target_object = target_file_key
+          else
+            target_object = target_directory_key + '/' + target_file_key
+          end
+          service.copy_object(nil, source_object, nil, target_object, options)
+          target_directory = service.directories.new(key: target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          service.delete_object(object)
+          true
+        end
+
+        def metadata
+          attributes[:metadata] ||= headers_to_metadata
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              display_name: new_owner['DisplayName'],
+              id: new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        # Get a url for file.
+        #
+        #     required attributes: directory, key
+        #
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        #
+        def url(expires, options = {})
+          requires :directory, :key
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          service.get_object_http_url_public(object, expires, options)
+        end
+
+        def public_url
+          requires :key
+          collection.get_url(key)
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          options['Content-Type'] = content_type if content_type
+          options['Content-Disposition'] = content_disposition if content_disposition
+          options.merge!(metadata_to_headers)
+
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          if body.is_a?(::File)
+            data = service.put_object(object, body, options).data
+          elsif body.is_a?(String)
+            data = service.put_object_with_body(object, body, options).data
+          else
+            raise Fog::Storage::Aliyun::Error, " Forbidden: Invalid body type: #{body.class}!"
+          end
+          update_attributes_from(data)
+          refresh_metadata
+
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        private
+
+        attr_writer :directory
+
+        def refresh_metadata
+          metadata.reject! { |_k, v| v.nil? }
+        end
+
+        def headers_to_metadata
+          key_map = key_mapping
+          Hash[metadata_attributes.map { |k, v| [key_map[k], v] }]
+        end
+
+        def key_mapping
+          key_map = metadata_attributes
+          key_map.each_pair { |k, _v| key_map[k] = header_to_key(k) }
+        end
+
+        def header_to_key(opt)
+          opt.gsub(metadata_prefix, '').split('-').map { |k| k[0, 1].downcase + k[1..-1] }.join('_').to_sym
+        end
+
+        def metadata_to_headers
+          header_map = header_mapping
+          Hash[metadata.map { |k, v| [header_map[k], v] }]
+        end
+
+        def header_mapping
+          header_map = metadata.dup
+          header_map.each_pair { |k, _v| header_map[k] = key_to_header(k) }
+        end
+
+        def key_to_header(key)
+          metadata_prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+
+        def metadata_attributes
+          if last_modified
+            object = if directory.key == ''
+                       key
+                     else
+                       directory.key + '/' + key
+                     end
+
+            headers = service.head_object(object).data[:headers]
+            headers.reject! { |k, _v| !metadata_attribute?(k) }
+          else
+            {}
+          end
+        end
+
+        def metadata_attribute?(key)
+          key.to_s =~ /^#{metadata_prefix}/
+        end
+
+        def metadata_prefix
+          'X-Object-Meta-'
+        end
+
+        def update_attributes_from(data)
+          merge_attributes(data[:headers].reject { |key, _value| ['Content-Length', 'Content-Type'].include?(key) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/storage/file'
+
+module Fog
+  module Storage
+    class Aliyun
+      class Files < Fog::Collection
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Aliyun::File
+
+        def all(_options = {})
+          requires :directory
+          if directory.key != '' && directory.key != '.' && !directory.key.nil?
+            prefix = directory.key + '/'
+          end
+          files = service.list_objects(prefix: prefix)['Contents']
+          return if nil == files
+          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 = if !lastModified.nil? && lastModified != ''
+                              Time.parse(lastModified).localtime
+                            end
+            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
+          end
+
+          load(data)
+        end
+
+        alias each_file_this_page each
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+
+            subset.each_file_this_page { |f| yield f }
+            while subset.length == (subset.limit || 10_000)
+              subset = subset.all(marker: subset.last.key)
+              subset.each_file_this_page { |f| yield f }
+            end
+
+            self
+          end
+        end
+
+        def get(key)
+          requires :directory
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          begin
+          data = service.get_object(object)
+          rescue => error
+            case error.response.body
+              when /<Code>NoSuchKey<\/Code>/
+                nil
+              else
+                raise(error)
+            end
+          end
+
+          contentLen = data[:headers]['Content-Length'].to_i
+
+          if block_given?
+            pagesNum = (contentLen + Excon::CHUNK_SIZE - 1) / Excon::CHUNK_SIZE
+
+            for i in 1..pagesNum
+              _start = (i - 1) * Excon::CHUNK_SIZE
+              _end = i * Excon::CHUNK_SIZE - 1
+              range = "#{_start}-#{_end}"
+              data = service.get_object(object, range)
+              chunk = data[:body]
+              yield(chunk)
+              body = nil
+            end
+          else
+            body = data[:body]
+          end
+
+          lastModified = data[:headers]['Last-Modified']
+          last_modified = if !lastModified.nil? && lastModified != ''
+                            Time.parse(lastModified).localtime
+                          end
+
+          date = data[:headers]['Date']
+          date = (Time.parse(date).localtime if !date.nil? && date != '')
+          file_data = {
+            body: body,
+            content_length: contentLen,
+            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'],
+            content_disposition: data[:headers]['Content-Disposition']
+          }
+
+          new(file_data)
+        end
+
+        def get_url(key)
+          requires :directory
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          service.get_object_http_url_public(object, 3600)
+        end
+
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          service.get_object_http_url_public(object, expires, options)
+        end
+
+        def get_https_url(key, expires, options = {})
+          requires :directory
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          service.get_object_https_url_public(object, expires, options)
+        end
+
+        def head(key, _options = {})
+          requires :directory
+          object = if directory.key == ''
+                     key
+                   else
+                     directory.key + '/' + key
+                   end
+          data = service.head_object(object).data
+          lastModified = data[:headers]['Last-Modified']
+          last_modified = if !lastModified.nil? && lastModified != ''
+                            Time.parse(lastModified).localtime
+                          end
+
+          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::Storage::Aliyun::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ directory: directory }.merge!(attributes))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aliyun/requests/compute/allocate_eip_address.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class Aliyun
+      class Real
+        # Allocate an eip IP address.
+        #
+        # ==== Notes
+        # The new eip Ip address would be avalable
+        # The allocated eip Ip address can only associate to the instance of the vpc in the same region
+        # Now the eip can support ICMP,TCP,UDP
+        # ==== Parameters
+        # * server_id<~String> - id of the instance
+        # * allocationId<~String> - id of the EIP
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'EipAddress'<~String> - the allocated eip address
+        #     * 'AllocationId'<~String> - the instance id on the public ip
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # {Aliyun API Reference}[https://docs.aliyun.com/?spm=5176.100054.201.106.DGkmH7#/pub/ecs/open-api/network&allocateeipaddress]
+        def allocate_eip_address(options = {})
+          _action = 'AllocateEipAddress'
+          _sigNonce = randonStr
+          _time = Time.new.utc
+
+          _parameters = defalutParameters(_action, _sigNonce, _time)
+          _pathURL = defaultAliyunUri(_action, _sigNonce, _time)
+
+          # optional parameters
+          _Bandwidth = options[:bandwidth]
+          if _Bandwidth
+            _parameters['Bandwidth'] = _Bandwidth
+            _pathURL += '&Bandwidth=' + _Bandwidth
+          end
+
+          _InternetChargeType = options[:internet_charge_type]
+          _InternetChargeType = 'PayByTraffic' unless _InternetChargeType
+          _parameters['InternetChargeType'] = _InternetChargeType
+          _pathURL += '&InternetChargeType=' + _InternetChargeType
+
+          _signature = sign(@aliyun_accesskey_secret, _parameters)
+          _pathURL += '&Signature=' + _signature
+
+          request(
+            expects: [200, 204],
+            method: 'GET',
+            path: _pathURL
+          )
+        end
+      end
+    end # aliyun
+  end # compute
+end

data/lib/fog/aliyun/requests/compute/allocate_public_ip_address.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Aliyun
+      class Real
+        # Allocate an avalable public IP address to the given instance.
+        #
+        # ==== Parameters
+        # * server_id<~String> - id of the instance
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'IpAddress'<~String> - The allocated ip address
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # {Aliyun API Reference}[https://docs.aliyun.com/?spm=5176.100054.201.106.DGkmH7#/pub/ecs/open-api/network&allocatepublicipaddress]
+        def allocate_public_ip_address(server_id)
+          _action = 'AllocatePublicIpAddress'
+          _sigNonce = randonStr
+          _time = Time.new.utc
+
+          _parameters = defalutParameters(_action, _sigNonce, _time)
+          _pathURL = defaultAliyunUri(_action, _sigNonce, _time)
+
+          _parameters['InstanceId'] = server_id
+          _pathURL += '&InstanceId=' + server_id
+
+          _signature = sign(@aliyun_accesskey_secret, _parameters)
+          _pathURL += '&Signature=' + _signature
+
+          request(
+            expects: [200, 204],
+            method: 'GET',
+            path: _pathURL
+          )
+        end
+      end
+    end # aliyun
+  end # compute
+end

data/lib/fog/aliyun/requests/compute/associate_eip_address.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class Aliyun
+      class Real
+        # Associate an avalable eip IP address to the given instance.
+        #
+        # ==== Parameters
+        # * server_id<~String> - id of the instance
+        # * allocationId<~String> - id of the EIP
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # {Aliyun API Reference}[https://docs.aliyun.com/?spm=5176.100054.201.106.DGkmH7#/pub/ecs/open-api/network&associateeipaddresss]
+        def associate_eip_address(server_id, allocationId, options = {})
+          _action = 'AssociateEipAddress'
+          _sigNonce = randonStr
+          _time = Time.new.utc
+
+          type = options['instance_type']
+
+          _parameters = defalutParameters(_action, _sigNonce, _time)
+          _pathURL = defaultAliyunUri(_action, _sigNonce, _time)
+
+          _parameters['InstanceId'] = server_id
+          _pathURL += '&InstanceId=' + server_id
+
+          _parameters['AllocationId'] = allocationId
+          _pathURL += '&AllocationId=' + allocationId
+
+          if type
+            _parameters['InstanceType'] = type
+            _pathURL += 'InstanceType=' + type
+          end
+
+          _signature = sign(@aliyun_accesskey_secret, _parameters)
+          _pathURL += '&Signature=' + _signature
+
+          request(
+            expects: [200, 204],
+            method: 'GET',
+            path: _pathURL
+          )
+        end
+      end
+    end # aliyun
+  end # compute
+end

data/lib/fog/aliyun/requests/compute/attach_disk.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Compute
+    class Aliyun
+      class Real
+        # Mount a disk.
+        #
+        # ==== Parameters
+        # * instanceId<~String> - id of the instance
+        # * diskId<~String> - id of the disk
+        # * options<~hash>
+        #     * :deleteWithInstance - if 'true',the disk will be relese with the instance.else, won't
+        #     * :device - if nil, the system will default allocate from /dev/xvdb to /dev/xvdz. default nil
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # {Aliyun API Reference}[https://docs.aliyun.com/?spm=5176.100054.201.106.DGkmH7#/pub/ecs/open-api/disk&attachdisk]
+        def attach_disk(instanceId, diskId, options = {})
+          action   = 'AttachDisk'
+          sigNonce = randonStr
+          time     = Time.new.utc
+
+          parameters = defalutParameters(action, sigNonce, time)
+          pathUrl    = defaultAliyunUri(action, sigNonce, time)
+
+          parameters['InstanceId'] = instanceId
+          pathUrl += '&InstanceId='
+          pathUrl += instanceId
+
+          parameters['DiskId'] = diskId
+          pathUrl += '&DiskId='
+          pathUrl += diskId
+
+          deleteWithInstance = options[:deleteWithInstance]
+          device             = options[:device]
+
+          deleteWithInstance = 'true' unless deleteWithInstance
+
+          parameters['DeleteWithInstance'] = deleteWithInstance
+          pathUrl += '&DeleteWithInstance='
+          pathUrl += deleteWithInstance
+
+          if device
+            parameters['Device'] = device
+            pathUrl += '&Device='
+            pathUrl += URI.encode(device, '/[^!*\'()\;?:@#&%=+$,{}[]<>`" ')
+          end
+
+          signature = sign(@aliyun_accesskey_secret, parameters)
+          pathUrl += '&Signature='
+          pathUrl += signature
+
+          request(
+            expects: [200, 203],
+            method: 'GET',
+            path: pathUrl
+          )
+        end
+      end
+
+      class Mock
+        def attach_volume(volume_id, server_id, device)
+          response = Excon::Response.new
+          response.status = 200
+          data = {
+            'id' => volume_id,
+            'volumeId' => volume_id,
+            'serverId' => server_id,
+            'device'   => device
+          }
+          self.data[:volumes][volume_id]['attachments'] << data
+          response.body = { 'volumeAttachment' => data }
+          response
+        end
+      end
+    end
+  end
+end