fog-aliyun 0.0.7

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

@@ -0,0 +1,178 @@
+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"]
+          if nil == files
+            return
+          end
+          data = Array.new
+          i = 0
+          files.each do |file|
+            if file["Key"][0][-1] != "/"
+	      content_length = file["Size"][0].to_i
+              key = file["Key"][0]
+              lastModified = file["LastModified"][0]
+              if lastModified != nil && lastModified != ""
+                last_modified = (Time.parse(lastModified)).localtime
+              else
+                last_modified = nil
+              end
+              data[i] = {:content_length => content_length,
+                         :key            => key,
+                         :last_modified  => last_modified,
+                         :etag           => file["ETag"][0]}
+              i = i + 1
+            end
+          end
+
+          load(data)
+          
+        end
+
+        alias_method :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 || 10000)
+              subset = subset.all(:marker => subset.last.key)
+              subset.each_file_this_page {|f| yield f}
+            end
+
+            self
+          end
+        end
+
+        def get(key, &block)
+          requires :directory
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          
+          data = service.head_object(object).data
+          contentLen = data[:headers]["Content-Length"].to_i
+          if data[:status] != 200
+            return nil
+          end
+          lastModified = data[:headers]["Last-Modified"]
+          if lastModified != nil && lastModified != ""
+            last_modified = (Time.parse(lastModified)).localtime
+          else
+            last_modified = nil
+          end
+
+          
+          file_data = {
+              :content_length => contentLen,
+              :key            => key,
+              :last_modified  => last_modified,
+              :content_type   => data[:headers]["Content-Type"],
+              :etag           => data[:headers]["ETag"]	
+          }
+          
+          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}"
+              chunk = service.get_object(object, range)[:body]
+              yield(chunk)
+            end
+            new(file_data)
+          else
+            data = service.get_object(object)
+            file_data.merge!(:body => data[:body])
+            new(file_data)
+          end
+          
+        end
+
+        def get_url(key)
+          requires :directory
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          service.get_object_http_url_public(object, 3600)
+        end
+
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          service.get_object_http_url_public(object, expires, options)
+        end
+
+        def get_https_url(key, expires, options = {})
+          requires :directory
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          service.get_object_https_url_public(object, expires, options)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          data = service.head_object(object).data
+          lastModified = data[:headers]["Last-Modified"]
+          if lastModified != nil && lastModified != ""
+            last_modified = (Time.parse(lastModified)).localtime
+          else
+            last_modified = nil
+          end
+
+          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"]	
+          }
+          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,79 @@
+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[:aliyun_Bandwidth]
+          if _Bandwidth
+            _parameters['Bandwidth']=_Bandwidth
+            _pathURL += '&Bandwidth='+_Bandwidth
+          end
+          
+          _InternetChargeType = options[:aliyun_InternetChargeType]
+          if _InternetChargeType
+            _parameters['InternetChargeType']=_InternetChargeType
+            _pathURL += '&InternetChargeType='+_InternetChargeType
+          end
+          
+          _signature = sign(@aliyun_accesskey_secret, _parameters)
+          _pathURL += '&Signature='+_signature
+          
+          request(
+            :expects => [200, 204],
+            :method => 'GET',
+            :path   => _pathURL
+          )
+        end
+      end
+
+      class Mock
+        def allocate_address(pool = nil)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-d4a21158-a86c-44a6-983a-e25645907f26",
+            "Content-Type" => "application/json",
+            "Content-Length" => "105",
+            "Date"=> Date.new
+          }
+          response.body = {
+            "floating_ip" => {
+              "instance_id" => nil,
+              "ip" => "192.168.27.132",
+              "fixed_ip" => nil,
+              "id" => 4,
+              "pool"=>"nova"
+            }
+          }
+          response
+        end
+      end # mock
+    end # aliyun
+  end #compute
+end

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

@@ -0,0 +1,63 @@
+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
+
+      class Mock
+        def allocate_address(pool = nil)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-d4a21158-a86c-44a6-983a-e25645907f26",
+            "Content-Type" => "application/json",
+            "Content-Length" => "105",
+            "Date"=> Date.new
+          }
+          response.body = {
+            "floating_ip" => {
+              "instance_id" => nil,
+              "ip" => "192.168.27.132",
+              "fixed_ip" => nil,
+              "id" => 4,
+              "pool"=>"nova"
+            }
+          }
+          response
+        end
+      end # mock
+    end # aliyun
+  end #compute
+end

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

@@ -0,0 +1,66 @@
+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)
+          
+          _action = 'AssociateEipAddress'
+          _sigNonce = randonStr()
+          _time = Time.new.utc
+
+          _parameters = defalutParameters(_action, _sigNonce, _time)
+          _pathURL  = defaultAliyunUri(_action, _sigNonce, _time)
+          
+          _parameters['InstanceId'] = server_id
+          _pathURL += '&InstanceId='+server_id
+          
+          _parameters['AllocationId'] = allocationId
+          _pathURL += '&AllocationId='+allocationId
+          
+          _signature = sign(@aliyun_accesskey_secret, _parameters)
+          _pathURL += '&Signature='+_signature
+          
+          request(
+            :expects => [200, 204],
+            :method => 'GET',
+            :path   => _pathURL
+          )
+        end
+      end
+
+      class Mock
+        def allocate_address(pool = nil)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "X-Compute-Request-Id" => "req-d4a21158-a86c-44a6-983a-e25645907f26",
+            "Content-Type" => "application/json",
+            "Content-Length" => "105",
+            "Date"=> Date.new
+          }
+          response.body = {
+            "floating_ip" => {
+              "instance_id" => nil,
+              "ip" => "192.168.27.132",
+              "fixed_ip" => nil,
+              "id" => 4,
+              "pool"=>"nova"
+            }
+          }
+          response
+        end
+      end # mock
+    end # Aliyun
+  end #compute
+end

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

@@ -0,0 +1,82 @@
+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]
+          
+          unless deleteWithInstance
+            deleteWithInstance = 'true' 
+          end
+
+          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