fog-aliyun 0.0.7

data/lib/fog/aliyun/models/compute/vswitch.rb

@@ -0,0 +1,70 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class Vswitch < Fog::Model
+        identity  :id,                  :aliases => 'VSwitchId'
+        attribute :vpc_id,              :aliases => 'VpcId'
+        attribute :zone_id,             :aliases => 'ZoneId'
+        attribute :name,                :aliases => 'VSwitchName'
+        attribute :available_ip_count,  :aliases => 'AvailableIpAddressCount'
+        attribute :state,               :aliases => 'Status'
+        attribute :cidr_block,          :aliases => 'CidrBlock'
+        attribute :description,      :aliases => 'Description'
+        attribute :region_id,        :aliases => 'RegionId'
+        attribute :creation_time,    :aliases => 'CreationTime'
+        def initialize(attributes={})
+          super
+        end
+
+        def ready?
+          requires :state
+          state == 'Available'
+        end
+
+        # Removes an existing vpc
+        #
+        # vpc.destroy
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+
+        def destroy
+          requires :id
+
+          service.delete_vswitch(id)
+          true
+        end
+
+        # Create a vpc
+        #
+        # >> g = Aliyun.vpcs.new(:cidr_block => "10.1.2.0/24")
+        # >> g.save
+        #
+        # == Returns:
+        #
+        # True or an exception depending on the result. Keep in mind that this *creates* a new vpc.
+        # As such, it yields an InvalidGroup.Duplicate exception if you attempt to save an existing vpc.
+        #
+
+        def save(options={})
+          requires :vpc,:cidr_block
+          data = Fog::JSON.decode(service.create_vswitch(vpc.id, cidr_block,options).body)
+
+          true
+        end
+
+        def vpc
+          $vpc
+        end
+        
+        def all()
+          data = Fog::JSON.decode(service.list_vswitchs(vpc_id).body)['VSwitches']['VSwitch']
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aliyun/models/compute/vswitches.rb

@@ -0,0 +1,87 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/vswitch'
+
+module Fog
+  module Compute
+    class Aliyun
+      class Vswitches < Fog::Collection
+        attribute :vpc
+        attribute :filters
+
+        model Fog::Compute::Aliyun::Vswitch
+
+        # Creates a new VPC
+        #
+        # Aliyun.vpcs.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new VPC
+        #
+        #>> Aliyun.vpcs.new
+        # <Fog::Aliyun::VPC::VPC
+        # id=nil,
+        # state=nil,
+        # cidr_block=nil,
+        # dhcp_options_id=nil
+        # tags=nil
+        # tenancy=nil
+        # >
+        #
+
+        def initialize(attributes)
+          self.filters ||={}
+          super
+        end
+
+        # Returns an array of all VPCs that have been created
+        #
+        # Aliyun.vpcs.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all VPCs
+        #
+        #>> Aliyun.vpcs.all
+        # <Fog::Aliyun::VPC::VPCs
+        # filters={}
+        # [
+        # <Fog::Aliyun::VPC::VPC
+        # id="vpc-12345678",
+        # TODO
+        # >
+        # ]
+        # >
+        #
+
+        def all(options={})
+          requires :vpc
+          data = Fog::JSON.decode(service.list_vswitchs(vpc.id, options).body)['VSwitches']['VSwitch']
+          load(data)
+        end
+
+        # Used to retrieve a VPC
+        # vpc_id is required to get the associated VPC information.
+        #
+        # You can run the following command to get the details:
+        # Aliyun.vpcs.get("vpc-12345678")
+        #
+        # ==== Returns
+        #
+        #>> Aliyun.vpcs.get("vpc-12345678")
+        # <Fog::Aliyun::Compute::VPC
+        # id="vpc-12345678",
+        # TODO
+        # >
+        #
+
+        def get(vswitchId)
+          requires :vpc
+          if vswitchId
+            self.class.new(:service => service,:vpc=>vpc).all(:vSwitchId=>vswitchId)[0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/storage/directory'
+
+module Fog
+  module Storage
+    class Aliyun
+      class Directories < Fog::Collection
+        model Fog::Storage::Aliyun::Directory
+
+        def all
+          containers = service.get_containers()
+          if nil == containers
+            return nil
+          end
+          data = Array.new
+          i = 0
+          containers.each do |entry|
+            key = entry["Prefix"][0]
+            key[-1] = ''
+            data[i] = {:key=>key}
+            i = i + 1
+          end
+
+          load(data)
+        end
+
+        def get(key, options = {})
+          if key != nil && key != "" && key != '.'
+            dir = key+'/'
+            ret = service.head_object(dir, options)
+            if ret.data[:status] == 200
+              new(:key => key)
+            else
+              nil
+            end
+          else
+            new(:key => "")
+          end
+        rescue Fog::Storage::Aliyun::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'fog/core/model'
+require 'fog/aliyun/models/storage/files'
+
+module Fog
+  module Storage
+    class Aliyun
+      class Directory < Fog::Model
+        identity  :key
+
+        def destroy
+          requires :key
+          prefix = key+'/'
+          ret = service.list_objects(:prefix=>prefix)["Contents"]
+          
+          if ret.nil?
+            puts " Not found: Direction not exist!"
+            false
+          elsif ret.size == 1
+            service.delete_container(key)
+            true
+          else
+            raise Fog::Storage::Aliyun::Error, " Forbidden: Direction not empty!"
+            false
+          end
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::Aliyun::Files.new(
+              :directory    => self,
+              :service   => service
+            )
+          end
+        end
+
+        def public_url
+          nil
+        end
+
+        def save
+          requires :key
+          service.put_container(key)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Aliyun
+      class File < Fog::Model
+        identity  :key,             :aliases => 'name'
+
+        attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :content_disposition, :aliases => ['content_disposition', 'Content-Disposition']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+        attribute :metadata
+        attribute :origin,          :aliases => ['Origin']
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key, options={})
+          requires :directory, :key
+          if directory.key == ""
+            source_object = key
+          else
+            source_object = 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
+          if directory.key == ""
+            object = key
+          else
+            object = 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
+          if directory.key == ""
+            object = key
+          else
+            object = directory.key+"/"+key
+          end
+          self.service.get_object_http_url_public(object, expires, options)
+        end
+
+        def public_url
+          requires :key
+          self.collection.get_url(self.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['Access-Control-Allow-Origin'] = access_control_allow_origin if access_control_allow_origin
+          options['Origin'] = origin if origin
+          options.merge!(metadata_to_headers)
+
+          if directory.key == ""
+            object = key
+          else
+            object = 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
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+        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
+            if directory.key == ""
+              object = key
+            else
+              object = 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