fog 2.1.0 → 2.3.0

data/lib/fog/cloudstack/models/compute/networks.rb

@@ -1,38 +0,0 @@
-
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/network'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class Networks < Fog::Collection
-        model Fog::Compute::Cloudstack::Network
-
-        def all(filters={})
-          options = get_filter_options(filters)
-          data = service.list_networks(options)["listnetworksresponse"]["network"] || []
-          load(data)
-        end
-
-        def get(network_id, filters={})
-          filter_option = get_filter_options(filters)
-          options = filter_option.merge('id' => network_id)
-          if data = service.list_networks(options)["listnetworksresponse"]["network"].first
-            new(data)
-          end
-        rescue Fog::Compute::Cloudstack::BadRequest
-          nil
-        end
-
-        private
-
-        def get_filter_options(filters)
-          default_filter = {
-              'projectfilter' => 'self'
-          }
-          default_filter.merge(filters)
-        end
-      end
-    end
-  end
-end

data/lib/fog/cloudstack/models/compute/port_forwarding_rule.rb

@@ -1,25 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class PortForwardingRule < Fog::Model
-        identity  :id,                      :aliases => 'id'
-
-        attribute :private_port,              :aliases => 'privateport'
-        attribute :private_end_port,          :aliases => 'privateendport'
-        attribute :protocol,                  :aliases => 'protocol'
-        attribute :public_port,               :aliases => 'publicport'
-        attribute :public_end_port,           :aliases => 'publicendport'
-        attribute :virtual_machine_id,        :aliases => 'virtualmachineid'
-        attribute :virtualmachinename,        :aliases => 'virtualmachinename'
-        attribute :virtualmachinedisplayname, :aliases => 'virtualmachinedisplayname'
-        attribute :ipaddressid,               :aliases => 'ipaddressid'
-        attribute :ipaddress,                 :aliases => 'ipaddress'
-        attribute :state,                     :aliases => 'state'
-        attribute :cidrlist,                  :aliases => 'cidrlist'
-        attribute :vmguestip,                 :aliases => 'vmguestip'
-        attribute :networkid,                 :aliases => 'networkid'
-        attribute :tags,                      :type => :array
-      end
-    end
-  end
-end

data/lib/fog/cloudstack/models/compute/port_forwarding_rules.rb

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/port_forwarding_rule'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class PortForwardingRules < Fog::Collection
-        model Fog::Compute::Cloudstack::PortForwardingRule
-
-        def all(options = {})
-          response = service.list_port_forwarding_rules(options)
-          port_forwarding_rules = response["listportforwardingrulesresponse"]["portforwardingrule"] || []
-          load(port_forwarding_rules)
-        end
-
-        def get(address_id)
-          options = { 'id' => address_id }
-          response = service.list_port_forwarding_rules(options)
-          port_forwarding_rules = response["listportforwardingrulesresponse"]["portforwardingrule"].first
-          new(port_forwarding_rules)
-        end
-      end
-    end
-  end
-end

data/lib/fog/cloudstack/models/compute/project.rb

@@ -1,58 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class Project < Fog::Model
-        identity  :id,                  :aliases => 'id'
-        attribute :name,                :aliases => 'name'
-        attribute :display_text,        :aliases => 'displaytext'
-        attribute :domain_id,           :aliases => 'domainid'
-        attribute :domain,              :aliases => 'domain'
-        attribute :account,             :aliases => 'account'
-        attribute :state,               :aliases => 'state'
-        attribute :tags,                :aliases => 'tags'
-        attribute :network_limit,       :aliases => 'networklimit'
-        attribute :network_total,       :aliases => 'networktotal', :type => :integer
-        attribute :network_available,   :aliases => 'networkavailable'
-        attribute :vpc_limit,           :aliases => 'vpclimit'
-        attribute :vpc_total,           :aliases => 'vpctotal', :type => :integer
-        attribute :vpc_available,       :aliases => 'vpcavailable'
-        attribute :cpu_limit,           :aliases => 'cpulimit'
-        attribute :cpu_total,           :aliases => 'cputotal', :type => :integer
-        attribute :cpu_available,       :aliases => 'cpuavailable'
-        attribute :memory_limit,        :aliases => 'memorylimit'
-        attribute :memory_total,        :aliases => 'memorytotal', :type => :integer
-        attribute :memory_available,            :aliases => 'memoryavailable'
-        attribute :primary_storage_limit,       :aliases => 'primarystoragelimit'
-        attribute :primary_storage_total,       :aliases => 'primarystoragetotal', :type => :integer
-        attribute :primary_storage_available,   :aliases => 'primarystorageavailable'
-        attribute :secondary_storage_limit,     :aliases => 'secondarystoragelimit'
-        attribute :secondary_storage_total,     :aliases => 'secondarystoragetotal', :type => :integer
-        attribute :secondary_storage_available, :aliases => 'secondarystorageavailable'
-        attribute :vm_limit,                    :aliases => 'vmlimit'
-        attribute :vm_total,                    :aliases => 'vmtotal', :type => :integer
-        attribute :vm_available,                :aliases => 'vmavailable'
-        attribute :ip_limit,                    :aliases => 'iplimit'
-        attribute :ip_total,                    :aliases => 'iptotal', :type => :integer
-        attribute :ip_available,                :aliases => 'ipavailable'
-        attribute :volume_limit,                :aliases => 'volumelimit'
-        attribute :volume_total,                :aliases => 'volumetotal', :type => :integer
-        attribute :volume_available,            :aliases => 'volumeavailable'
-        attribute :snapshot_limit,              :aliases => 'snapshotlimit'
-        attribute :snapshot_total,              :aliases => 'snapshottotal', :type => :integer
-        attribute :snapshot_available,          :aliases => 'snapshotavailable'
-        attribute :template_limit,              :aliases => 'templatelimit'
-        attribute :template_total,              :aliases => 'templatetotal', :type => :integer
-        attribute :template_available,          :aliases => 'templateavailable'
-
-        def save
-          raise Fog::Errors::Error.new('Creating a project is not supported')
-        end
-
-        def destroy
-          raise Fog::Errors::Error.new('Destroying a project is not supported')
-        end
-
-      end # Project
-    end # Cloudstack
-  end # Compute
-end # Fog

data/lib/fog/cloudstack/models/compute/projects.rb

@@ -1,39 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/project'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class Projects < Fog::Collection
-        model Fog::Compute::Cloudstack::Project
-
-        def all(filters={})
-          options = get_filter_options(filters)
-
-          data = service.list_projects(options)["listprojectsresponse"]["project"] || []
-          load(data)
-        end
-
-        def get(project_id, filters={})
-          filter_option = get_filter_options(filters)
-          options = filter_option.merge('id' => project_id)
-
-          if template = service.list_projects(options)["listprojectsresponse"]["project"].first
-            new(template)
-          end
-        rescue Fog::Compute::Cloudstack::BadRequest
-          nil
-        end
-
-        private
-
-        def get_filter_options(filters)
-          default_filter = {
-              'projectfilter' => 'self'
-          }
-          default_filter.merge(filters)
-        end
-      end
-    end
-  end
-end

data/lib/fog/cloudstack/models/compute/public_ip_address.rb

@@ -1,96 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class PublicIpAddress < Fog::Model
-        identity  :id
-
-        attribute :account
-        attribute :allocated,               :type => :time
-        attribute :associated_network_id,                      :aliases => 'associatednetworkid'
-        attribute :associated_network_name,                    :aliases => 'associatednetworkname'
-        attribute :domain
-        attribute :domain_id,                                  :aliases => 'domainid'
-        attribute :for_virtual_network,     :type => :boolean, :aliases => 'forvirtualnetwork'
-        attribute :ip_address,                                 :aliases => 'ipaddress'
-        attribute :is_portable,             :type => :boolean, :aliases => 'isportable'
-        attribute :is_source_nat,           :type => :boolean, :aliases => 'issourcenat'
-        attribute :is_static_nat,           :type => :boolean, :aliases => 'isstaticnat'
-        attribute :is_system,               :type => :boolean, :aliases => 'issystem'
-        attribute :network_id,              :type => :boolean, :aliases => 'networkid'
-        attribute :physical_network_id,                        :aliases => 'physicalnetworkid'
-        attribute :project
-        attribute :project_id,                                 :aliases => 'projectid'
-        attribute :purpose
-        attribute :state
-        attribute :server_display_name,                        :aliases => 'virtualmachinedisplayname'
-        attribute :server_id,                                  :aliases => 'virtualmachineid'
-        attribute :server_name,                                :aliases => 'virtualmachinename'
-        attribute :vlan_id,                                    :aliases => 'vlanid'
-        attribute :vlan_name,                                  :aliases => 'vlanname'
-        attribute :server_ip_address,                          :aliases => 'vmipaddress'
-        attribute :vpc_id,                                     :aliases => 'vpcid'
-        attribute :zone_id,                                    :aliases => 'zoneid'
-        attribute :zone_name,                                  :aliases => 'zonename'
-        attribute :tags,                    :type => :array
-        attribute :job_id,                                     :aliases => 'jobid'   # only on associate
-
-        def initialize(attributes = {})
-          # assign server first to prevent race condition with persisted?
-          self.server = attributes.delete(:server)
-          super
-        end
-
-        def ready?
-          state == 'Allocated'
-        end
-
-        def destroy
-          requires :identity
-          service.disassociate_ip_address('id' => id)
-          true
-        end
-
-        def server=(new_server)
-          @server = new_server
-          if persisted?
-            if !server_id.nil? && (new_server.nil? || server_id != new_server.id)
-              service.disable_static_nat('ipaddressid' => id)
-              self.server_display_name = nil
-              self.server_id = nil
-              self.server_name = nil
-              self.server_ip_address = nil
-              self.is_static_nat = false
-            end
-            unless new_server.nil?
-              service.enable_static_nat(
-                'ipaddressid' => id, 'virtualmachineid' => new_server.id)
-            end
-          end
-        end
-
-        def server
-          service.servers.get(server_id)
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          options = {
-            'account'    => account,
-            'domainid'   => domain_id,
-            'isportable' => is_portable,
-            'networkid'  => network_id,
-            'projectid'  => project_id,
-            'vpcid'      => vpc_id,
-            'zoneid'     => zone_id,
-          }
-          response = service.associate_ip_address(options)
-          merge_attributes(response['associateipaddressresponse'])
-          if @server
-            self.server = @server
-          end
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/cloudstack/models/compute/public_ip_addresses.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/public_ip_address'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class PublicIpAddresses < Fog::Collection
-        model Fog::Compute::Cloudstack::PublicIpAddress
-
-        def all(options = {})
-          response = service.list_public_ip_addresses(options)
-          public_ip_addresses = response["listpublicipaddressesresponse"]["publicipaddress"] || []
-          load(public_ip_addresses)
-        end
-
-        def get(address_id)
-          response = service.list_public_ip_addresses('id' => address_id)
-          if public_ip_address = response["listpublicipaddressesresponse"]["publicipaddress"].first
-            new(public_ip_address)
-          end
-        rescue Fog::Compute::Cloudstack::BadRequest
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class SecurityGroup < Fog::Model
-        identity  :id,            :aliases => 'id'
-        attribute :name,                                     :type => :string
-        attribute :description,                              :type => :string
-        attribute :account,                                  :type => :string
-        attribute :domain_id,     :aliases => "domainid",    :type => :string
-        attribute :domain_name,   :aliases => "domain",      :type => :string
-        attribute :project_id,    :aliases => "projectid",   :type => :string
-        attribute :project_name,  :aliases => "project",     :type => :string
-        attribute :ingress_rules, :aliases => "ingressrule", :type => :array
-        attribute :egress_rules,  :aliases => "egressrule",  :type => :array
-
-        def destroy
-          requires :id
-          service.delete_security_group('id' => self.id)
-          true
-        end
-
-        def egress_rules
-          attributes[:egress_rules] || []
-        end
-
-        def ingress_rules
-          attributes[:ingress_rules] || []
-        end
-
-        def save
-          requires :name
-
-          options = {
-            'name'        => self.name,
-            'account'     => self.account,
-            'description' => self.description,
-            'projectid'   => self.project_id,
-            'domainid'    => self.domain_id,
-          }
-          data = service.create_security_group(options)
-          merge_attributes(data['createsecuritygroupresponse']['securitygroup'])
-        end
-
-        def rules
-          service.security_group_rules.all("security_group_id" => self.id)
-        end
-      end # SecurityGroup
-    end # Cloudstack
-  end # Compute
-end # Fog

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

@@ -1,60 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class SecurityGroupRule < Fog::Model
-        identity  :id,                :aliases => 'ruleid'
-
-        attribute :security_group_id, :type => :string
-        attribute :protocol,          :type => :string
-        attribute :start_port,        :type => :integer, :aliases => 'startport'
-        attribute :end_port,          :type => :integer, :aliases => 'endport'
-        attribute :cidr,              :type => :string
-        attribute :direction,         :type => :string
-
-        def destroy
-          data = service.send("revoke_security_group_#{self.direction}", "id" => self.id)
-          job = service.jobs.new(data["revokesecuritygroup#{self.direction}"])
-          job.wait_for { ready? }
-          job.successful?
-        end
-
-        def port_range
-          (self.start_port..self.end_port)
-        end
-
-        def save
-          requires :security_group_id, :cidr, :direction
-
-          data = service.send("authorize_security_group_#{self.direction}".to_sym, params)
-          job = service.jobs.new(data["authorizesecuritygroup#{self.direction}response"])
-          job.wait_for { ready? }
-          # durty
-          merge_attributes(job.result.send("#{self.direction}_rules").last)
-          self
-        end
-
-        def security_group
-          service.security_groups.get(self.security_group_id)
-        end
-
-        def reload
-          requires :id, :security_group_id, :cidr
-
-          merge_attributes(security_group.rules.get(self.id))
-        end
-
-        private
-
-        def params
-          options = {
-            "securitygroupid" => self.security_group_id,
-            "protocol"        => self.protocol,
-            "cidrlist"        => self.cidr
-          }
-          options.merge!("startport" => self.start_port) unless self.start_port.nil?
-          options.merge("endport" => self.end_port) unless self.end_port.nil?
-        end
-      end # SecurityGroupRule
-    end # Cloudstack
-  end # Compute
-end # Fog

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

@@ -1,35 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/security_group_rule'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class SecurityGroupRules < Fog::Collection
-        model Fog::Compute::Cloudstack::SecurityGroupRule
-
-        attribute :security_group_id, :type => :string
-
-        def security_group
-          service.security_groups.get(self.security_group_id)
-        end
-
-        def create(attributes)
-          model = self.new(attributes.merge(:security_group_id => self.security_group_id))
-          model.save
-        end
-
-        def all(options={})
-          merge_attributes(options)
-          security_group = self.security_group
-          rules = security_group.ingress_rules.map{|r| r.merge("direction" => "ingress", "security_group_id" => security_group_id)}
-          rules += security_group.egress_rules.map{|r| r.merge("direction" => "egress", "security_group_id" => security_group_id)}
-          load(rules)
-        end
-
-        def get(rule_id)
-          all.find{|r| r.id == rule_id}
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/security_group'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class SecurityGroups < Fog::Collection
-        model Fog::Compute::Cloudstack::SecurityGroup
-
-        def all(options={})
-          data = service.list_security_groups(options)["listsecuritygroupsresponse"]["securitygroup"] || []
-          load(data)
-        end
-
-        def get(security_group_id)
-          if security_group = service.list_security_groups('id' => security_group_id)["listsecuritygroupsresponse"]["securitygroup"].first
-            new(security_group)
-          end
-        rescue Fog::Compute::Cloudstack::BadRequest
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class Server < Fog::Compute::Server
-        identity  :id,                                      :aliases => 'id'
-        attribute :name
-        attribute :account_name,                            :aliases => 'account'
-        attribute :domain_name,                             :aliases => 'domain'
-        attribute :created,              :type => :time
-        attribute :state
-        attribute :haenable
-        attribute :memory
-        attribute :display_name,                            :aliases => 'displayname'
-        attribute :domain_id,                               :aliases => 'domainid'
-        attribute :host_id,                                 :aliases => 'hostid'
-        attribute :host_name,                               :aliases => 'hostname'
-        attribute :project_id,                              :aliases => 'projectid'
-        attribute :zone_id,                                 :aliases => 'zoneid'
-        attribute :zone_name,                               :aliases => 'zonename'
-        attribute :image_id,                                :aliases => ['templateid', :template_id]
-        attribute :image_name,                              :aliases => ['templatename', :template_name]
-        attribute :templated_display_text,                  :aliases => 'templatedisplaytext'
-        attribute :password_enabled,                        :aliases => 'passwordenabled'
-        attribute :flavor_id,                               :aliases => ['serviceofferingid', :service_offering_id]
-        attribute :flavor_name,                             :aliases => ['serviceofferingname', :service_offering_name]
-        attribute :cpu_number,                              :aliases => 'cpunumber'
-        attribute :cpu_speed,                               :aliases => 'cpuspeed'
-        attribute :cpu_used,                                :aliases => 'cpuused'
-        attribute :network_kbs_read,                        :aliases => 'networkkbsread'
-        attribute :network_kbs_write,                       :aliases => 'networkkbswrite'
-        attribute :guest_os_id,                             :aliases => 'guestosid'
-        attribute :root_device_id,                          :aliases => 'rootdeviceid'
-        attribute :root_device_type,                        :aliases => 'rootdevicetype'
-        attribute :group
-        attribute :key_name,                                :aliases => 'keypair'
-        attribute :user_data,                                :aliases => 'userdata'
-        attribute :security_group_list,    :type => :array, :aliases => 'securitygroup'
-        attribute :nics,                   :type => :array, :aliases => 'nic'
-        attribute :job_id,                                  :aliases => 'jobid'   # only on create
-        attribute :size,                   :type => :integer
-        attribute :root_disk_size,         :type => :integer
-
-        attr_accessor :network_ids, :disk_offering_id, :ip_address, :ip_to_network_list
-        attr_writer :security_group_ids
-
-        alias_method :public_ip_address, :ip_address
-        alias_method :public_ip_address=, :ip_address=
-
-        def addresses
-          nics.map{|nic| Address.new(nic)}
-        end
-
-        def ip_addresses
-          addresses.map(&:ip_address)
-        end
-
-        def volumes
-          requires :id
-          service.volumes.all('virtualmachineid' => id)
-        end
-
-        def reset_password
-          requires :id
-          data = service.reset_password_for_virtual_machine(id)
-          service.jobs.new(data['resetpasswordforvirtualmachineresponse'])
-        end
-
-        def public_ip_addresses
-          if public_ip_address.nil? then [public_ip_address] else [] end
-        end
-
-        def private_ip_addresses
-          ip_addresses - public_ip_addresses
-        end
-
-        def private_ip_address
-          private_ip_addresses.first
-        end
-
-        def destroy(options={})
-          requires :id
-          data = service.destroy_virtual_machine(options.merge({'id'=> self.id}))
-          service.jobs.new(data["destroyvirtualmachineresponse"])
-        end
-
-        def flavor
-          service.flavors.get(self.flavor_id)
-        end
-
-        def ready?
-          state == 'Running'
-        end
-
-        def reboot
-          requires :id
-          data = service.reboot_virtual_machine('id' => self.id) # FIXME: does this ever fail?
-          service.jobs.new(data["rebootvirtualmachineresponse"])
-        end
-
-        def security_groups=(security_groups)
-          self.security_group_ids= Array(security_groups).map(&:id)
-        end
-
-        def security_group_ids
-          @security_group_ids || (self.security_group_list || []).map{|sg| sg["id"]}
-        end
-
-        def security_groups
-          security_group_ids.map{|id| service.security_groups.get(id)}
-        end
-
-        def save
-          requires :image_id, :flavor_id, :zone_id
-
-          options = {
-            'templateid'        => image_id,
-            'serviceofferingid' => flavor_id,
-            'zoneid'            => zone_id,
-            'networkids'        => network_ids,
-            'diskofferingid'    => disk_offering_id,
-            'name'              => name,
-            'displayname'       => display_name,
-            'group'             => group,
-            'domainid'          => domain_id,
-            'hostid'            => host_id,
-            'ipaddress'         => ip_address,
-            'iptonetworklist'   => ip_to_network_list,
-            'projectid'         => project_id,
-            'keypair'           => key_name,
-            'userdata'          => user_data,
-            'size'              => size,
-          }
-
-          options.merge!('rootdisksize' => root_disk_size) if root_disk_size
-          options.merge!('networkids' => network_ids) if network_ids
-          options.merge!('securitygroupids' => security_group_ids) unless security_group_ids.empty?
-
-          data = service.deploy_virtual_machine(options)
-          merge_attributes(data['deployvirtualmachineresponse'])
-        end
-
-        def start
-          requires :id
-          data = service.start_virtual_machine("id" => self.id)
-          service.jobs.new(data["startvirtualmachineresponse"])
-        end
-
-        def stop(options={})
-          requires :id
-          unless options.is_a?(Hash)
-            Fog::Logger.deprecation("Passing force as a boolean option has been deprecated. Please pass a hash with 'force' => (true|false)")
-            options = {'force' => options}
-          end
-          data = service.stop_virtual_machine(options.merge({'id' => self.id}))
-          service.jobs.new(data["stopvirtualmachineresponse"])
-        end
-      end # Server
-    end # Cloudstack
-  end # Compute
-end # Fog