fog-aliyun 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3832cc5a22287a780d5db5052856762bdeb92015
-  data.tar.gz: f203d9aee9f037683ada71ade9bd94d660c12d81
+  metadata.gz: 8f039d826c1b8f347bd39065fca8d8c8d1a3a513
+  data.tar.gz: 883c955e643d7d333571a41ce98f30ce16706a40
 SHA512:
-  metadata.gz: c0a398c13920fd1a2cc963c5e932795a15a7e291018c9926081e5f6359a1b4c3fc4c9345bd6b5876e0038cfe4993d2987378930fed213792993671fa1ecda918
-  data.tar.gz: 15555676894ee0653f605f6aed1f3d0a35fa48e0fe266427ef873240dd3d89165ade2204800079903faf5abe37ef780412c67295db8bb8838c2d5b8448b316bd
+  metadata.gz: a315a64cbbd5ae803e0064ac3b063dcab53b7970cf4e6aa0c0ee70abddf0273cc7e9cfde587f627f6bcf5ddc931a9153b883e2f4b6e5ae86f78d0170181cc362
+  data.tar.gz: e700199fed03abeeec6cd02f7c313ce6fee29c7f72ac6d5aca366ea83621c474f286ce313c4ba3a32ba0b5a75b7170ee798057e3ee0d120ba63fdc3a1d746480

data/fog-aliyun.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Fog provider for Aliyun Web Services.}
   spec.description   = %q{As a FOG provider, fog-aliyun support aliyun OSS/ECS. It will support more aliyun services later.}
-  spec.homepage      = "https://github.com/dtdream/fog-aliyun.git"
+  spec.homepage      = "https://github.com/fog/fog-aliyun"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

data/lib/fog/aliyun/compute.rb

@@ -10,10 +10,30 @@ module Fog
       ## MODELS
       #
       model_path 'fog/aliyun/models/compute'
+      model       :server
+      collection  :servers
+      model       :image
+      collection  :images
+      model       :eip_address
+      collection  :eip_addresses
+      model       :security_group
+      collection  :security_groups
+      model       :security_group_rule
+      collection  :security_group_rules
+      model       :volume
+      collection  :volumes
+      model       :snapshot
+      collection  :snapshots
       model       :vpc
       collection  :vpcs
       model       :vswitch
       collection  :vswitches
+      model       :vrouter
+      collection  :vrouters
+      model       :route_table
+      collection  :route_tables
+      model       :route_entry
+      collection  :route_entrys
 
       ## REQUESTS
       #
@@ -59,9 +79,13 @@ module Fog
       request :create_security_group
       request :create_security_group_ip_rule
       request :create_security_group_sg_rule
+      request :create_security_group_egress_ip_rule
+      request :create_security_group_egress_sg_rule
       request :delete_security_group
       request :delete_security_group_ip_rule
       request :delete_security_group_sg_rule
+      request :delete_security_group_egress_ip_rule
+      request :delete_security_group_egress_sg_rule
       request :join_security_group
       request :leave_security_group
 
@@ -78,6 +102,13 @@ module Fog
       request :delete_vswitch
       request :list_vswitchs
       request :modify_vpc
+      request :modify_vswitch
+
+      #VRouter
+      request :list_vrouters
+
+      #RouteTable
+      request :list_route_tables
 
       
       #clouddisk

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

@@ -0,0 +1,63 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class EipAddress < Fog::Model
+
+        identity :id,             :aliases => 'AllocationId'
+
+        attribute :allocated_at,  :aliases => 'AllocationTime'
+        attribute :bandwidth,     :aliases => 'Bandwidth'
+        attribute :server_id,     :aliases => 'InstanceId'
+        attribute :charge_type,   :aliases => 'InternetChargeType'
+        attribute :ip_address,    :aliases => ['IpAddress','EipAddress']
+        attribute :opertion_locks,:aliases => 'OperationLocks'
+        attribute :region_id,     :aliases => 'RegionId'
+        attribute :state,         :aliases => 'Status'
+
+        def destroy
+          requires :id
+          service.release_eip_address(id)
+          true
+        end
+
+        def ready?
+          requires :state
+          state == 'Available'
+        end
+
+        def save(options={})
+          # raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          # requires :availability_zone
+          options[:bandwidth] = bandwidth if bandwidth
+          options[:internet_charge_type]=charge_type if charge_type
+          
+          data = Fog::JSON.decode(service.allocate_eip_address(options).body)
+          merge_attributes(data)         
+          true
+        end
+
+
+        def associate(new_server,options={})
+          unless persisted?
+            @server = new_server
+          else
+            @server = nil
+            self.server_id = new_server.id
+            service.associate_eip_address(server_id,id,options)
+          end
+        end
+
+        def disassociate(new_server,options={})
+            @server = nil
+            self.server_id = new_server.id
+          if persisted?
+            service.unassociate_eip_address(server_id,id,options)
+          end
+          
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/eip_address'
+
+module Fog
+  module Compute
+    class Aliyun
+      class EipAddresses < Fog::Collection
+
+        model Fog::Compute::Aliyun::EipAddress 
+
+        def all(filters_arg = {})
+          data = Fog::JSON.decode(service.list_eip_addresses(filters_arg).body)['EipAddresses']['EipAddress']
+          load(data)
+          # load(data['volumeSet'])
+          # if server
+          #   self.replace(self.select {|volume| volume.server_id == server.id})
+          # end
+          # self
+        end
+
+        def get(allocation_id)
+          if allocation_id
+            self.class.new(:service => service).all(:allocation_id => allocation_id)[0]
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class Image < Fog::Model
+
+        identity :id,                     :aliases => 'ImageId'
+
+        attribute :description,           :aliases => 'Description'
+        attribute :product_code,          :aliases => 'ProductCode'
+        attribute :os_type,               :aliases => 'OSType'
+        attribute :architecture,          :aliases => 'Architecture'
+        attribute :os_name,               :aliases => 'OSName'
+        attribute :disk_device_mappings,  :aliases => 'DiskDeviceMappings'
+        attribute :owner_alias,           :aliases => 'ImageOwnerAlias'
+        attribute :progress,              :aliases => 'Progress'
+        attribute :usage,                 :aliases => 'Usage'
+        attribute :created_at,            :aliases => 'CreationTime'
+        attribute :tags,                  :aliases => 'Tags'
+        attribute :version,               :aliases => 'ImageVersion'
+        attribute :state,                 :aliases => 'Status'
+        attribute :name,                  :aliases => 'ImageName'
+        attribute :is_self_shared,        :aliases => 'IsSelfShared'
+        attribute :is_copied,             :aliases => 'IsCopied'
+        attribute :is_subscribed,         :aliases => 'IsSubscribed'
+        attribute :platform,              :aliases => 'Platform'
+        attribute :size,                  :aliases => 'Size'
+        attribute :snapshot_id,           :aliases => 'SnapshotId'
+
+        def initialize(attributes)
+          self.snapshot_id=attributes["DiskDeviceMappings"]["DiskDeviceMapping"][0]["SnapshotId"]
+          super
+        end
+
+        def save (options={})
+          requires :snapshot_id
+          options[:name] = name if name
+          options[:description]=description if description
+          data=Fog::JSON.decode(service.create_image(snapshot_id,options).body)
+          merge_attributes(data)
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_image(id)
+          true
+        end
+
+        def ready?
+          state == 'Available'
+        end
+
+        def snapshot
+          requires :snapshot_id
+          Fog::Compute::Aliyun::Snapshots.new(:service=>service).all(:snapshotIds=>[snapshot_id])[0]
+        end
+
+        private
+
+        def snapshot=(new_snapshot)
+          self.snapshot_id = new_snapshot.id
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/image'
+
+module Fog
+  module Compute
+    class Aliyun
+      class Images < Fog::Collection
+
+        model Fog::Compute::Aliyun::Image
+
+
+        def all(filters_arg = {})
+          unless filters_arg.is_a?(Hash)
+            Fog::Logger.deprecation("all with #{filters_arg.class} param is deprecated, use all('diskIds' => []) instead [light_black](#{caller.first})[/]")
+            filters_arg = {:imageId => filters_arg}
+          end
+          data = Fog::JSON.decode(service.list_images(filters_arg).body)['Images']['Image']
+          load(data)
+        end
+
+        def get(image_id)
+          if image_id
+            self.class.new(:service => service).all(:imageId => image_id)[0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class RouteEntry < Fog::Model
+
+        # "RouteTables"=>{"RouteTable"=>[
+        #  {"CreationTime"=>"2015-08-03T11:23:35Z", "RouteEntrys"=>{"RouteEntry"=>[
+        #    {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.0.0/24"},
+        #    {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.1.0/24"}, 
+        #    {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.2.0/24"}, 
+        #    {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"100.64.0.0/10"}, 
+        #    {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"10.0.0.0/8"}]},
+        #  "RouteTableId"=>"vtb-2504onoxh", "RouteTableType"=>"System", "VRouterId"=>"vrt-25azmd2wm"}]}
+        identity :cidr_block,         :aliases => 'DestinationCidrBlock'
+        attribute :state,             :aliases => 'Status'
+        attribute :server_id,         :aliases => 'InstanceId'
+        attribute :type,              :aliases => 'Type'
+        attribute :route_table_id,    :aliases => 'RouteTableId'
+
+        # def save
+        #   requires :cidr_block,:route_table_id
+        #   if(cidr_block)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/route_entry'
+
+module Fog
+  module Compute
+    class Aliyun
+      class RouteEntrys < Fog::Collection
+        attribute :route_table
+
+        model Fog::Compute::Aliyun::RouteEntry
+
+        def all(options={})
+          requires :route_table
+          options[:routeTableId]=route_table.id
+          data = Fog::JSON.decode(service.list_route_tables(route_table.v_router_id, options).body)['RouteTables']['RouteTable'][0]["RouteEntrys"]["RouteEntry"]
+          load(data)
+        end
+
+        def get(cidr_block)
+          requires :route_table
+          data=self.class.new(:service=>service,:route_table=>route_table).all()
+          result=nil
+          data.each do |i|
+            if i.cidr_block==cidr_block
+              result=i
+              break
+            end
+          end
+          result
+        end
+
+        # def get(routeTableId)
+        #   requires :v_router
+        #   if routeTableId
+        #     self.class.new(:service => service,:v_router=>v_router).all(:routeTableId=>routeTableId)[0]
+        #   end
+        # end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class RouteTable < Fog::Model
+
+        # "RouteTables"=>{"RouteTable"=>[
+        # {"CreationTime"=>"2015-08-03T11:23:35Z", "RouteEntrys"=>{"RouteEntry"=>[
+        #   {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.0.0/24"},
+        #   {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.1.0/24"}, 
+        #   {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"172.16.2.0/24"}, 
+        #   {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"100.64.0.0/10"}, 
+        #   {"Status"=>"Available", "Type"=>"System", "InstanceId"=>"", "RouteTableId"=>"vtb-2504onoxh", "DestinationCidrBlock"=>"10.0.0.0/8"}]},
+        #  "RouteTableId"=>"vtb-2504onoxh", "RouteTableType"=>"System", "VRouterId"=>"vrt-25azmd2wm"}]}
+        identity :id,             :aliases => 'RouteTableId'
+        attribute :created_at,    :aliases => 'CreationTime'
+        attribute :type,          :aliases => 'RouteTableType'
+        attribute :v_router_id,   :aliases => 'VRouterId'
+        # collection Fog::Compute::Aliyun::RouteEntrys
+        def route_entrys
+          @route_entrys ||= begin
+            Fog::Compute::Aliyun::RouteEntrys.new(
+              :route_table    => self,
+              :service   => service
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/route_table'
+
+module Fog
+  module Compute
+    class Aliyun
+      class RouteTables < Fog::Collection
+        attribute :v_router
+
+        model Fog::Compute::Aliyun::RouteTable
+
+        def all(options={})
+          requires :v_router
+          data = Fog::JSON.decode(service.list_route_tables(v_router.id, options).body)['RouteTables']['RouteTable']
+          load(data)
+        end
+
+        def get(routeTableId)
+          requires :v_router
+          if routeTableId
+            self.class.new(:service => service,:v_router=>v_router).all(:routeTableId=>routeTableId)[0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Aliyun
+      class SecurityGroup < Fog::Model
+        identity  :id,           :aliases =>"SecurityGroupId"
+        attribute :name,         :aliases => "SecurityGroupName"
+        attribute :description,  :aliases => "Description"
+        attribute :created_at,   :aliases => "CreationTime"
+        attribute :vpc_id,       :aliases => "VpcId"
+
+        def vpc
+          requires :vpc_id
+          service.vpcs.get(vpc_id)
+        end
+
+        def security_group_rules
+          requires :id
+          service.security_group_rules.get(id)
+        end
+
+        def save(options={})
+          options[:vpcId] = vpc_id if vpc_id
+          options[:name] = name if name
+          options[:description] = description if description
+          Fog::JSON.decode(service.create_security_group(options).body)
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_security_group(id)
+          true
+        end
+
+        def authorize_security_group_sg_rule(group_id,direction="ingress",options={})
+          requires :id
+          if direction=="egress"
+            service.create_security_group_egress_sg_rule(id,group_id,options)
+          else
+            service.create_security_group_sg_rule(id,group_id,options)
+          end
+          true
+        end
+
+        def authorize_security_group_ip_rule(cidr_ip,direction="ingress",options={})
+          requires :id
+          nic_type = options.fetch(:nic_type, "internet")
+          if direction=="egress"
+            service.create_security_group_egress_ip_rule(id,cidr_ip,nic_type,options)
+          else
+            service.create_security_group_ip_rule(id,cidr_ip,nic_type,options)
+          end
+          true
+        end
+
+        def revoke_seurity_group_sg_rule(group_id,direction="ingress",options={})
+          requires :id
+          if direction=="egress"
+            service.delete_security_group_egress_sg_rule(id,group_id,options)
+          else
+            service.delete_security_group_sg_rule(id,group_id,options)
+          end
+          true
+        end
+
+        def revoke_security_group_ip_rule(cidr_ip,direction="ingress",options={})
+          requires :id
+          nic_type = options.fetch(:nic_type, "internet")
+          if direction=="egress"
+            service.delete_security_group_egress_ip_rule(id,cidr_ip,nic_type,options)
+          else
+            service.delete_security_group_ip_rule(id,cidr_ip,nic_type,options)
+          end
+          true
+        end
+      end
+    end
+  end
+end