fog 2.1.0 → 2.2.0

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

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/job'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class Jobs < Fog::Collection
-        model Fog::Compute::Cloudstack::Job
-
-        def all
-          data = service.list_async_jobs["listasyncjobsresponse"]["asyncjobs"] || []
-          load(data)
-        end
-
-        def get(job_id)
-          if job = service.query_async_job_result('jobid' => job_id)["queryasyncjobresultresponse"]
-            new(job)
-          end
-        rescue Fog::Compute::Cloudstack::BadRequest
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class Network < Fog::Model
-        identity  :id,                      :aliases => 'id'
-        attribute :name,                    :aliases => 'name'
-        attribute :display_text,            :aliases => 'displaytext'
-
-        attribute :broadcast_domain_type,   :aliases => 'broadcastdomaintype'
-        attribute :traffic_type,            :aliases => 'traffictype'
-        attribute :gateway,                 :aliases => 'gateway'
-        attribute :cidr,                    :aliases => 'cidr'
-        attribute :zone_id,                 :aliases => 'zoneid'
-        attribute :zone_name,               :aliases => 'zonename'
-
-        attribute :network_offering_id,            :aliases => 'networkofferingid'
-        attribute :network_offering_name,          :aliases => 'networkofferingname'
-        attribute :network_offering_display_text,  :aliases => 'networkofferingdisplaytext'
-        attribute :network_offering_conserve_mode, :aliases => 'networkofferingconservemode'
-        attribute :network_offering_availability,  :aliases => 'networkofferingavailability'
-        attribute :is_system,               :aliases => 'issystem', :type => :boolean
-        attribute :state,                   :aliases => 'state'
-
-        attribute :related,                 :aliases => 'related'
-        attribute :dns1,                    :aliases => 'dns1'
-        attribute :dns2,                    :aliases => 'dns2'
-        attribute :type,                    :aliases => 'type'
-        attribute :acl_type,                :aliases => 'acltype'
-        attribute :project_id,              :aliases => 'projectid'
-        attribute :domain_id,               :aliases => 'domainid'
-        attribute :domain,                  :aliases => 'domain'
-
-        # attribute :service,                 :aliases => 'service'
-        attribute :network_domain,          :aliases => 'domain'
-        attribute :physical_network_id,     :aliases => 'physicalnetworkid'
-        attribute :restart_required,        :aliases => 'restartrequired'
-        attribute :specify_ip_ranges,       :aliases => 'specifyipranges'
-        attribute :canuse_for_deploy,       :aliases => 'canusefordeploy'
-        attribute :is_persistent,           :aliases => 'ispersistent', :type => :boolean
-        attribute :display_network,         :aliases => 'displaynetwork'
-        attribute :is_default,              :aliases => 'isdefault', :type => :boolean
-
-        # restart network - will return a job
-        def restart(options={})
-            response = service.restart_network( options.merge({'id'=> self.id}))
-            service.jobs.new(response['restartnetworkresponse'])
-        end
-
-        # create a new network
-        def save
-          requires :display_text, :name, :network_offering_id, :zone_id
-
-          options = {
-            'displaytext'           => display_text,
-            'name'                  => name,
-            'zoneid'                => zone_id,
-            'networkofferingid'     => network_offering_id
-          }
-
-          response = service.create_network(options)
-          merge_attributes(response['createnetworkresponse']['network'])
-        end
-
-        # delete given network - will return a job
-        def destroy(options={})
-          response = service.delete_network(options.merge({'id'=> self.id}))
-          service.jobs.new(response["deletenetworkresponse"])
-        end
-
-      end # Network
-    end # Cloudstack
-  end # Compute
-end # Fog

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

@@ -1,25 +0,0 @@
-module Fog
-  module Compute
-    class Cloudstack
-      class NetworkOffering < Fog::Model
-        identity  :id,                      :aliases => 'id'
-        attribute :name,                    :aliases => 'name'
-        attribute :display_text,            :aliases => 'displaytext'
-        attribute :traffic_type,            :aliases => 'traffictype'
-        attribute :is_default,              :aliases => 'isdefault', :type => :boolean
-        attribute :specify_vlan,            :aliases => 'specifyvlan'
-        attribute :conserve_mode,           :aliases => 'conservemode'
-        attribute :specify_ip_ranges,       :aliases => 'specifyipranges'
-        attribute :availability,            :aliases => 'availability'
-        attribute :network_rate,            :aliases => 'networkrate'
-        attribute :state,                   :aliases => 'state'
-        attribute :guest_ip_type,           :aliases => 'guestiptype'
-        attribute :service_offering_id,     :aliases => 'serviceofferingid'
-        attribute :service,                 :aliases => 'service'
-        attribute :for_vpc,                 :aliases => 'forvpc'
-        attribute :is_persistent,           :aliases => 'ispersistent', :type => :boolean
-        attribute :egress_default_policy,   :aliases => 'egressdefaultpolicy'
-      end # NetworkOffering
-    end # Cloudstack
-  end # Compute
-end # Fog

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

@@ -1,39 +0,0 @@
-
-
-require 'fog/core/collection'
-require 'fog/cloudstack/models/compute/network_offering'
-
-module Fog
-  module Compute
-    class Cloudstack
-      class NetworkOfferings < Fog::Collection
-        model Fog::Compute::Cloudstack::NetworkOffering
-
-        def all(filters={})
-          options = get_filter_options(filters)
-          data = service.list_network_offerings(options)["listnetworkofferingsresponse"]["networkoffering"] || []
-          load(data)
-        end
-
-        def get(network_offering_id, filters={})
-          filter_option = get_filter_options(filters)
-          options = filter_option.merge('id' => network_offering_id)
-          if data = service.list_network_offerings(options)["listnetworkofferingsresponse"]["networkoffering"].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/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