fog-xiaozhu 0.2.1

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

@@ -0,0 +1,30 @@
+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

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

@@ -0,0 +1,47 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Aliyun
+      class SecurityGroupRule < Fog::Model
+        attribute :security_group_id,         aliases: 'SecurityGroupId'
+        attribute :source_cidr_ip,            aliases: 'SourceCidrIp'
+        attribute :source_owner,              aliases: 'SourceGroupOwnerAccount'
+        attribute :source_group_id,           aliases: 'SourceGroupId'
+        attribute :ip_protocol,               aliases: 'IpProtocol'
+        attribute :dest_cidr_ip,              aliases: 'DestCidrIp'
+        attribute :dest_owner,                aliases: 'DestGroupOwnerAccount'
+        attribute :dest_group_id,             aliases: 'DestGroupId'
+        attribute :nic_type,                  aliases: 'NicType'
+        attribute :policy,                    aliases: 'Policy'
+        attribute :port_range,                aliases: 'PortRange'
+        attribute :direction,                 aliases: 'Direction'
+        attribute :priority,                  aliases: 'Priority'
+
+        def save
+          requires :security_group_id, :ip_protocol, :port_range, :direction
+          options = {}
+          options[:portRange] = port_range if port_range
+          options[:policy] = policy if policy
+          options[:priority] = priority if port_range
+          options[:protocol] = ip_protocol if ip_protocol
+          if direction == 'egress'
+            if dest_cidr_ip
+              service.create_security_group_egress_ip_rule(security_group_id, dest_cidr_ip, nic_type, options)
+            elsif dest_group_id
+              options[:destGroupOwnerAccount] = dest_owner if dest_owner
+              service.create_security_group_egress_sg_rule(security_group_id, dest_group_id, options)
+            end
+          else
+            if source_cidr_ip
+              service.create_security_group_ip_rule(security_group_id, source_cidr_ip, nic_type, options)
+            elsif source_group_id
+              options[:sourceGroupOwnerAccount] = source_owner if source_owner
+              service.create_security_group_sg_rule(security_group_id, source_group_id, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/security_group_rule'
+
+module Fog
+  module Compute
+    class Aliyun
+      class SecurityGroupRules < Fog::Collection
+        model Fog::Compute::Aliyun::SecurityGroupRule
+        attribute :security_group_id
+
+        def get(security_group_id, options = {})
+          data = Fog::JSON.decode(service.list_security_group_rules(security_group_id, options).body)
+          self.security_group_id = data['SecurityGroupId']
+          permissions = data['Permissions']['Permission']
+          permissions.each do |permission|
+            permission['SecurityGroupId'] = self.security_group_id
+          end
+          load(permissions)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/security_group'
+
+module Fog
+  module Compute
+    class Aliyun
+      class SecurityGroups < Fog::Collection
+        model Fog::Compute::Aliyun::SecurityGroup
+
+        def all(options = {})
+          data = Fog::JSON.decode(service.list_security_groups(options).body)['SecurityGroups']['SecurityGroup']
+          load(data)
+          # ['Images']['Image']
+        end
+
+        def get(security_group_id)
+          if security_group_id
+            data = self.class.new(service: service).all
+            result = nil
+            data.each do |i|
+              if i.id == security_group_id
+                result = i
+                break
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Aliyun
+      class Server < Fog::Compute::Server
+        identity :id,                 aliases: 'InstanceId'
+        attribute :image_id,          aliases: 'ImageId'
+        attribute :inner_ip,          aliases: 'InnerIpAddress'
+        attribute :vlan_id,           aliases: 'VlanId'
+        attribute :eip,               aliases: 'EipAddress'
+        attribute :max_bandwidth_in,  aliases: 'InternetMaxBandwidthIn'
+        attribute :zone_id,           aliases: 'ZoneId'
+        attribute :internet_charge_type,       aliases: 'InternetChargeType'
+        attribute :serial_number,     aliases: 'SerialNumber'
+        attribute :io_optimized,      aliases: 'IoOptimized'
+        attribute :max_bandwidth_out, aliases: 'InternetMaxBandwidthOut'
+        attribute :vpc_attributes,    aliases: 'VpcAttributes'
+        attribute :device_available,  aliases: 'DeviceAvailable'
+        attribute :private_ip,        aliases: 'PrivateIpAddress'
+        attribute :security_group_ids, aliases: 'SecurityGroupIds'
+        attribute :name,              aliases: 'InstanceName'
+        attribute :description,       aliases: 'Description'
+        attribute :network_type,      aliases: 'InstanceNetworkType'
+        attribute :public_ip,         aliases: 'PublicIpAddress'
+        attribute :host_name,         aliases: 'HostName'
+        attribute :type,              aliases: 'InstanceType'
+        attribute :created_at,        aliases: 'CreationTime'
+        attribute :state,             aliases: 'Status'
+        attribute :cluster_id,        aliases: 'ClusterId'
+        attribute :region_id,         aliases: 'RegionId'
+        attribute :charge_type,       aliases: 'InstanceChargeType'
+        attribute :operation_locks,   aliases: 'OperationLocks'
+        attribute :expired_at,        aliases: 'ExpiredTime'
+
+        def image
+          requires image_id
+          Fog::Compute::Aliyun::Image.new(service: service).all(imageId: image_id)[0]
+        end
+
+        def vpc
+          requires :vpc_id
+          $vpc = Fog::Compute::Aliyun::Vpcs.new(service: service).all('vpcId' => vpc_id)[0]
+        end
+
+        # {"ImageId"=>"ubuntu1404_32_20G_aliaegis_20150325.vhd", "InnerIpAddress"=>{"IpAddress"=>["10.171.90.171"]},
+        #  "VlanId"=>"", "InstanceId"=>"i-25d1ry3jz",
+        # "EipAddress"=>{"IpAddress"=>"", "AllocationId"=>"", "InternetChargeType"=>""},
+        # "InternetMaxBandwidthIn"=>-1, "ZoneId"=>"cn-beijing-a", "InternetChargeType"=>"PayByTraffic",
+        # "SerialNumber"=>"9b332890-35e8-45c9-8e52-14e1156a4f58", "IoOptimized"=>false, "InternetMaxBandwidthOut"=>1,
+        # "VpcAttributes"=>{"NatIpAddress"=>"", "PrivateIpAddress"=>{"IpAddress"=>[]}, "VSwitchId"=>"", "VpcId"=>""},
+        # "DeviceAvailable"=>true, "SecurityGroupIds"=>{"SecurityGroupId"=>["sg-25rgacf5p"]}, "InstanceName"=>"iZ25d1ry3jzZ",
+        # "Description"=>"", "InstanceNetworkType"=>"classic", "PublicIpAddress"=>{"IpAddress"=>["123.57.73.19"]},
+        # "HostName"=>"iZ25d1ry3jzZ", "InstanceType"=>"ecs.t1.small", "CreationTime"=>"2015-10-13T14:57Z", "Status"=>"Stopped",
+        #  "ClusterId"=>"", "RegionId"=>"cn-beijing", "InstanceChargeType"=>"PostPaid", "OperationLocks"=>{
+        #  "LockReason"=>[{"LockReason"=>"financial"}]}, "ExpiredTime"=>"2015-10-14T20:53Z"}
+
+        # @!attribute [rw] personality
+        # @note This attribute is only used for server creation. This field will be nil on subsequent retrievals.
+        # @return [Hash] Hash containing data to inject into the file system of the cloud server instance during server creation.
+        # @example To inject fog.txt into file system
+        #   :personality => [{ :path => '/root/fog.txt',
+        #                      :contents => Base64.encode64('Fog was here!')
+        #                   }]
+        # @see #create
+        # @see http://docs.openstack.org/api/openstack-compute/2/content/Server_Personality-d1e2543.html
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/server'
+
+module Fog
+  module Compute
+    class Aliyun
+      class Servers < Fog::Collection
+        model Fog::Compute::Aliyun::Server
+
+        def all(options = {})
+          Fog::JSON.decode(service.list_servers(options).body)['Instances']['Instance']
+        end
+
+        # Creates a new server and populates ssh keys
+        # @return [Fog::Compute::OpenStack::Server]
+        # @raise [Fog::Compute::OpenStack::NotFound] - HTTP 404
+        # @raise [Fog::Compute::OpenStack::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::OpenStack::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::OpenStack::ServiceError]
+        # @example
+        #   service.servers.bootstrap :name => 'bootstrap-server',
+        #                             :flavor_ref => service.flavors.first.id,
+        #                             :image_ref => service.images.find {|img| img.name =~ /Ubuntu/}.id,
+        #                             :public_key_path => '~/.ssh/fog_rsa.pub',
+        #                             :private_key_path => '~/.ssh/fog_rsa'
+        #
+        #        def bootstrap(new_attributes = {})
+        #          server = create(new_attributes)
+        #          server.wait_for { ready? }
+        #          server.setup(:password => server.password)
+        #          server
+        #        end
+
+        def get(server_id)
+          if server_id
+            self.class.new(service: service).all(instanceId: server_id)[0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class Snapshot < Fog::Model
+        identity  :id,          aliases: 'SnapshotId'
+        attribute :name,        aliases: 'SnapshotName'
+        attribute :description, aliases: 'Description'
+        attribute :progress,    aliases: 'Progress'
+        attribute :volume_id,     aliases: 'SourceDiskId'
+        attribute :volume_size,   aliases: 'SourceDiskSize'
+        attribute :volume_type,   aliases: 'SourceDiskType'
+        attribute :product_code, aliases: 'ProductCode'
+        attribute :created_at,  aliases: 'CreationTime'
+        attribute :state,       aliases: 'Status'
+        attribute :usage,       aliases: 'Usage'
+        attribute :tags,        aliases: 'Tags'
+
+        def destroy
+          requires :id
+          service.delete_snapshot(id)
+          true
+        end
+
+        def ready?
+          state == 'accomplished'
+        end
+
+        def save(options = {})
+          # raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :volume_id
+          options[:name] = name if name
+          options[:description] = description if description
+          data = Fog::JSON.decode(service.create_snapshot(volume_id, options).body)
+          merge_attributes(data)
+          true
+        end
+
+        def volume
+          requires :volume_id
+          Fog::Compute::Aliyun::Volumes.new(service: service).all(diskIds: [volume_id])[0]
+        end
+
+        private
+
+        def volume=(new_volume)
+          self.volume_id = new_volume.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/aliyun/models/compute/snapshot'
+
+module Fog
+  module Compute
+    class Aliyun
+      class Snapshots < Fog::Collection
+        # attribute :filters
+        model Fog::Compute::Aliyun::Snapshot
+
+        # def initialize(attributes)
+        #   self.filters ||= {}
+        #   super
+        # end
+
+        def all(filters_arg = {})
+          unless filters_arg.is_a?(Hash)
+            Fog::Logger.deprecation("all with #{filters_arg.class} param is deprecated, use all('snapshotIds' => []) instead [light_black](#{caller.first})[/]")
+            filters_arg = { 'snapshotIds' => [*filters_arg] }
+          end
+          volume_id = filters_arg[:volume_id]
+          volume_type = filters_arg[:volume_type]
+          filters_arg[:diskId] = volume_id if volume_id
+          filters_arg[:sourseDiskType] = volume_type if volume_type
+          data = Fog::JSON.decode(service.list_snapshots(filters_arg).body)['Snapshots']['Snapshot']
+          load(data)
+        end
+
+        def get(snapshot_id)
+          if snapshot_id
+            snapshotIds = Array.new(1, snapshot_id)
+            self.class.new(service: service).all(snapshotIds: snapshotIds)[0]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'fog/core/model'
+module Fog
+  module Compute
+    class Aliyun
+      class Volume < Fog::Model
+        # "ImageId": "",
+        # "InstanceId": "",
+        # "OperationLocks": {
+        #     "OperationLock": []
+        # },
+        # "Portable": true,
+        # "ProductCode": "",
+        # "RegionId": "cn-qingdao",
+        # "Size": 5,
+        # "SourceSnapshotId": "",
+        # "Status": "Available",
+        # "Type": "data",
+
+        identity  :id,                    aliases: 'DiskId'
+        attribute :region_id,             aliases: 'RegionId'
+        attribute :zone_id,               aliases: 'ZoneId'
+        attribute :name,                  aliases: 'DiskName'
+        attribute :description,           aliases: 'Description'
+        attribute :type,                  aliases: 'Type'
+        attribute :category,              aliases: 'Category'
+        attribute :size,                  aliases: 'Size'
+        attribute :image_id,              aliases: 'ImageId'
+        attribute :snapshot_id,           aliases: 'SourceSnapshotId'
+        attribute :product_code,          aliases: 'ProductCode'
+        attribute :portable,              aliases: 'Portable'
+        attribute :state,                 aliases: 'Status'
+        attribute :operation_locks,       aliases: 'OperationLocks'
+        attribute :server_id,             aliases: 'InstanceId'
+        attribute :device,                aliases: 'Device'
+        attribute :delete_with_instance,  aliases: 'DeleteWithInstance'
+        attribute :delete_auto_snapshot,  aliases: 'DeleteAutoSnapshot'
+        attribute :enable_auto_snapshot,  aliases: 'EnableAutoSnapshot'
+        attribute :created_at,            aliases: 'CreationTime'
+        attribute :attached_at,           aliases: 'AttachedTime'
+        attribute :detached_at,           aliases: 'DetachedTime'
+        attribute :expired_at,            aliases: 'ExpiredTime'
+        attribute :charge_type,           aliases: 'DiskChargeType'
+        attribute :tags,                  aliases: 'Tags'
+
+        def destroy
+          requires :id
+
+          service.delete_disk(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
+          requires_one :size, :snapshot_id
+          options[:name] = name if name
+          options[:description] = description if description
+          if snapshot_id
+            data = Fog::JSON.decode(service.create_disk_by_snapshot(snapshot_id, options).body)
+            merge_attributes(data)
+          elsif size
+            data = Fog::JSON.decode(service.create_disk(size, options).body)
+            merge_attributes(data)
+          end
+
+          true
+        end
+
+        def image
+          requires :image_id
+          Fog::Compute::Aliyun::Images.new(service: service).all(imageId: image_id)[0]
+        end
+
+        def snapshots
+          requires :id
+          Fog::Compute::Aliyun::Snapshots.new(service: service).all(volume_id: id)
+        end
+
+        def source
+          requires :snapshot_id
+          Fog::Compute::Aliyun::Snapshots.new(service: service).all(snapshotIds: [snapshot_id])[0]
+        end
+
+        private
+
+        def source=(new_source)
+          self.snapshot_id = new_source.id
+        end
+
+        def image=(new_image)
+          self.image_id = new_image.id
+        end
+      end
+    end
+  end
+end