fog 1.26.0 → 1.27.0

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

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+module Fog
+  module Compute
+    class Cloudstack
+      class PublicIpAddress < Fog::Model
+        identity  :id,                    :aliases => 'id'
+        attribute :network_id,            :aliases => 'networkid'
+        attribute :associated_network_id, :aliases => 'associatednetworkid'
+        attribute :physical_network_id,   :aliases => 'physicalnetworkid'
+        attribute :ip_address,            :aliases => 'ipaddress'
+        attribute :mac_address,           :aliases => 'macaddress'
+        attribute :state,                 :aliases => 'state'
+        attribute :traffic_type,          :aliases => 'traffictype'
+        attribute :is_default,            :aliases => 'isdefault', :type => :boolean
+        attribute :is_source_nat,         :aliases => 'issourcenat', :type => :boolean
+        attribute :is_static_nat,         :aliases => 'isstaticnat', :type => :boolean
+        attribute :is_system,             :aliases => 'issytem', :type => :boolean
+        attribute :is_portable,           :aliases => 'isportable', :type => :boolean
+        attribute :allocated,             :aliases => 'allocated', :type => :time
+        attribute :zone_id,               :aliases => 'zone_id'
+        attribute :domain_id,             :aliases => 'domain_id'
+        attribute :tags,                  :type => :array
+        attribute :type
+
+       def save
+          requires :display_text, :name
+
+          options = {
+            'displaytext' => display_text,
+            'name'        => name,
+            'customized'  => is_customized,
+            'disksize'    => disk_size,
+            'domain_id'   => domain_id,
+            'storagetype' => storage_type,
+            'tags'        => tags
+          }
+
+          response = service.associate_ip_address(options)
+          merge_attributes(response['associateipaddressresponse'])
+        end
+
+        def destroy
+          requires :id
+
+          response = service.disassociate_ip_address('id' => id )
+          success_status = response['disassociateipaddressresponse']['success']
+
+          success_status == 'true'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cloudstack/models/compute/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)
+          options = { 'id' => address_id }
+          response = service.list_public_ip_addresses(options)
+          public_ip_addresses = response["listpublicipaddressesresponse"]["publicipaddress"].first
+          new(public_ip_addresses)
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Fog
         attribute :name
         attribute :account_name,                            :aliases => 'account'
         attribute :domain_name,                             :aliases => 'domain'
-        attribute :created
+        attribute :created,              :type => :time
         attribute :state
         attribute :haenable
         attribute :memory
@@ -38,6 +38,7 @@ module Fog
         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
 
         attr_accessor :network_ids, :disk_offering_id, :ip_address, :ip_to_network_list
         attr_writer :security_group_ids
@@ -126,7 +127,7 @@ module Fog
             'iptonetworklist'   => ip_to_network_list,
             'projectid'         => project_id,
             'keypair'           => key_name,
-            'userdata'           => user_data,
+            'userdata'          => user_data,
           }
 
           options.merge!('networkids' => network_ids) if network_ids

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

@@ -8,6 +8,7 @@ module Fog
         model Fog::Compute::Cloudstack::Server
 
         def all(attributes={})
+          # add project id if we have one
           response = service.list_virtual_machines(attributes)
           data = response["listvirtualmachinesresponse"]["virtualmachine"] || []
           load(data)
@@ -20,7 +21,9 @@ module Fog
         end
 
         def get(server_id)
-          servers = service.list_virtual_machines('id' => server_id)["listvirtualmachinesresponse"]["virtualmachine"]
+          attributes = {'id' => server_id}
+          # add project id if we have one
+          servers = service.list_virtual_machines(attributes)["listvirtualmachinesresponse"]["virtualmachine"]
           if servers.nil? || servers.empty?
             servers = service.list_virtual_machines('id' => server_id, 'projectid' => '-1')["listvirtualmachinesresponse"]["virtualmachine"]
           end

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

@@ -25,6 +25,7 @@ module Fog
         attribute :server_id,                  :aliases => 'virtualmachineid'
         attribute :server_name,                :aliases => 'vmname'
         attribute :server_display_name,        :aliases => 'vmdisplayname'
+        attribute :job_id,                     :aliases => 'jobid'   # only on create
 
         attr_accessor :snapshot_id, :project_id
 
@@ -39,6 +40,7 @@ module Fog
             'snapshotid'     => snapshot_id,
             'projectid'      => project_id
           }
+
           data = service.create_volume(options)
           merge_attributes(data['createvolumeresponse'])
         end

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

@@ -31,6 +31,7 @@ module Fog
           data = service.create_zone(options)
           merge_attributes(data['createzoneresponse'])
         end
+
       end # Zone
     end # Cloudstack
   end # Compute

data/lib/fog/cloudstack/requests/compute/associate_ip_address.rb

@@ -10,14 +10,45 @@ module Fog
           options = {}
           if args[0].is_a? Hash
             options = args[0]
-            options.merge!('command' => 'associateIpAddress') 
+            options.merge!('command' => 'associateIpAddress')
           else
             options.merge!('command' => 'associateIpAddress')
           end
+          # add project id if we have one
+          @cloudstack_project_id ? options.merge!('projectid' => @cloudstack_project_id) : nil
           request(options)
         end
       end
 
+      class Mock
+        def associate_ip_address(*args)
+          public_ip_address = {
+            "id"                => "f2f2f2f2-f2f2-f2f2-f2f2-f2f2f2f2f2",
+            "ipaddress"         => "192.168.200.3",
+            "allocated"         => "2014-12-22T22:32:39+0000",
+            "zoneid"            => "0e276270-7950-4483-bf21-3dc897dbe08a",
+            "zonename"          => "Toronto",
+            "issourcenat"       => false,
+            "projectid"         => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1",
+            "project"           => "TestProject",
+            "domainid"          => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1",
+            "domain"            => "TestDomain",
+            "forvirtualnetwork" => true,
+            "isstaticnat"       => false,
+            "issystem"          => false,
+            "associatednetworkid" => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1",
+            "associatednetworkname" => "TestNetwork",
+            "networkid"         => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1",
+            "state"             => "Allocated",
+            "physicalnetworkid" => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1",
+            "tags"              => []
+
+          }
+          self.data[:public_ip_addresses][public_ip_address_id]= public_ip_address
+          {'associateipaddressresponse' => public_ip_address}
+        end
+      end
+
     end
   end
 end