fog 1.4.0 → 1.5.0

data/lib/fog/cloudstack/compute.rb

@@ -27,6 +27,10 @@ module Fog
       collection :servers
       model :image
       collection :images
+      model :security_group
+      collection :security_groups
+      model :security_group_rule
+      collection :security_group_rules
       model :volume
       collection :volumes
       model :zone
@@ -34,7 +38,9 @@ module Fog
 
       request :acquire_ip_address
       request :assign_to_load_balancer_rule
+      request :assign_virtual_machine
       request :attach_volume
+      request :authorize_security_group_egress
       request :authorize_security_group_ingress
       request :change_service_for_virtual_machine
       request :create_account
@@ -48,6 +54,7 @@ module Fog
       request :create_snapshot_policy
       request :create_user
       request :create_volume
+      request :create_zone
       request :delete_account
       request :delete_domain
       request :delete_load_balancer_rule
@@ -80,6 +87,7 @@ module Fog
       request :list_events
       request :list_external_firewalls
       request :list_external_load_balancers
+      request :list_firewall_rules
       request :list_hosts
       request :list_hypervisors
       request :list_instance_groups
@@ -115,6 +123,7 @@ module Fog
       request :remove_from_load_balancer_rule
       request :reset_password_for_virtual_machine
       request :revoke_security_group_ingress
+      request :revoke_security_group_egress
       request :start_virtual_machine      
       request :stop_virtual_machine
       request :update_account
@@ -247,23 +256,20 @@ module Fog
 
         def self.data
           @data ||= begin
-            rc_options = Fog.credentials[:cloudstack] || {}
-            zone_id = rc_options[:zone_id] ||"c554c592-e09c-9df5-7688-4a32754a4305"
-            image_id = rc_options[:image_id] || "8a31cf9c-f248-0588-256e-9dbf58785216"
-            flavor_id =  rc_options[:flavor_id] || "4437ac6c-9fe3-477a-57ec-60a5a45896a4"
-            account_id = "8bec6f15-e2b8-44fc-a8f3-a022b2873440"
-            user_id = Fog::Cloudstack.uuid
-            domain_id = Fog::Cloudstack.uuid
-            network_id = (Array(rc_options[:network_ids]) || [Fog::Cloudstack.uuid]).first
+            zone_id     = Fog.credentials[:cloudstack_zone_id]             || Fog::Cloudstack.uuid
+            image_id    = Fog.credentials[:cloudstack_template_id]         || Fog::Cloudstack.uuid
+            flavor_id   = Fog.credentials[:cloudstack_service_offering_id] || Fog::Cloudstack.uuid
+            network_id  = (Array(Fog.credentials[:cloudstack_network_ids]) || [Fog::Cloudstack.uuid]).first
             domain_name = "exampleorg"
+            account_id, user_id, domain_id = Fog::Cloudstack.uuid, Fog::Cloudstack.uuid, Fog::Cloudstack.uuid
             domain = {
-              "id" => domain_id,
-              "name" => domain_name,
-              "level" => 1,
-              "parentdomainid" => Fog::Cloudstack.uuid,
+              "id"               => domain_id,
+              "name"             => domain_name,
+              "level"            => 1,
+              "parentdomainid"   => Fog::Cloudstack.uuid,
               "parentdomainname" => "ROOT",
-              "haschild" => false,
-              "path" => "ROOT/accountname"
+              "haschild"         => false,
+              "path"             => "ROOT/accountname"
             }
             user = {
               "id"          => user_id,
@@ -406,10 +412,11 @@ module Fog
                 "state"             => "enabled",
                 "user"              => [user]}
               },
-              :domains => { domain_id => domain },
-              :servers => {},
-              :jobs    => {},
-              :volumes => {}
+              :domains         => {domain_id => domain},
+              :servers         => {},
+              :jobs            => {},
+              :volumes         => {},
+              :security_groups => {},
             }
           end
         end

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

@@ -2,60 +2,60 @@ module Fog
   module Compute
     class Cloudstack
       class Image < Fog::Model
-        identity  :id,              :aliases => 'id'
+        identity  :id,                 :aliases => 'id'
         attribute :account
-        attribute :account_id, :aliases => 'accountid'
+        attribute :account_id,         :aliases => 'accountid'
         attribute :bootable
         attribute :checksum
         attribute :created
-        attribute :cross_zones, :aliases => 'crossZones'
+        attribute :cross_zones,        :aliases => 'crossZones'
         attribute :details
-        attribute :display_text, :aliases => 'displaytext'
+        attribute :display_text,       :aliases => 'displaytext'
         attribute :domain
-        attribute :domain_id, :aliases => 'domainid'
+        attribute :domain_id,          :aliases => 'domainid'
         attribute :format
-        attribute :host_id, :aliases => 'hostid'
-        attribute :host_name, :aliases => 'hostname'
+        attribute :host_id,            :aliases => 'hostid'
+        attribute :host_name,          :aliases => 'hostname'
         attribute :hypervisor
-        attribute :job_id, :aliases => 'jobid'
-        attribute :job_status, :aliases => 'jobstatus'
-        attribute :is_extractable, :aliases => 'isextractable'
-        attribute :is_featured, :aliases => 'isfeatured'
-        attribute :is_public, :aliases => 'ispublic'
-        attribute :is_ready, :aliases => 'isready'
+        attribute :job_id,             :aliases => 'jobid'
+        attribute :job_status,         :aliases => 'jobstatus'
+        attribute :is_extractable,     :aliases => 'isextractable'
+        attribute :is_featured,        :aliases => 'isfeatured'
+        attribute :is_public,          :aliases => 'ispublic'
+        attribute :is_ready,           :aliases => 'isready'
         attribute :name
-        attribute :os_type_id, :aliases => 'ostypeid'
-        attribute :os_type_name, :aliases => 'ostypename'
-        attribute :password_enabled, :aliases => 'ostypename'
+        attribute :os_type_id,         :aliases => 'ostypeid'
+        attribute :os_type_name,       :aliases => 'ostypename'
+        attribute :password_enabled,   :aliases => 'ostypename'
         attribute :project
-        attribute :project_id, :aliases => 'projectid'
+        attribute :project_id,         :aliases => 'projectid'
         attribute :removed
         attribute :size
         attribute :source_template_id, :aliases => 'sourcetemplateid'
         attribute :status
-        attribute :template_tag, :aliases => 'templatetag'
-        attribute :template_type, :aliases => 'templatetype'
-        attribute :zone_id, :aliases => 'zoneid'
-        attribute :zone_name, :aliases => 'zonename'
+        attribute :template_tag,       :aliases => 'templatetag'
+        attribute :template_type,      :aliases => 'templatetype'
+        attribute :zone_id,            :aliases => 'zoneid'
+        attribute :zone_name,          :aliases => 'zonename'
 
         attr_accessor :bits, :requires_hvm, :snapshot_id, :url, :virtual_machine_id, :volume_id
 
         def save
           options = {
-            'displaytext' => display_text,
-            'name' => name,
-            'ostypeid' => os_type_id,
-            'bits' => bits,
-            'details' => details,
-            'isfeatured' => is_featured,
-            'ispublic' => is_public,
-            'passwordenabled' => password_enabled,
-            'requireshvm' => requires_hvm,
-            'snapshotid' => snapshot_id,
-            'templatetag' => template_tag,
-            'url' => url,
+            'displaytext'      => display_text,
+            'name'             => name,
+            'ostypeid'         => os_type_id,
+            'bits'             => bits,
+            'details'          => details,
+            'isfeatured'       => is_featured,
+            'ispublic'         => is_public,
+            'passwordenabled'  => password_enabled,
+            'requireshvm'      => requires_hvm,
+            'snapshotid'       => snapshot_id,
+            'templatetag'      => template_tag,
+            'url'              => url,
             'virtualmachineid' => virtual_machine_id,
-            'volumeid' => volume_id
+            'volumeid'         => volume_id
           }
           data = connection.create_template(options)
           merge_attributes(data['createtemplateresponse'])

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

@@ -20,9 +20,22 @@ module Fog
           merge_attributes(connection.query_async_job_result('jobid' => self.id)['queryasyncjobresultresponse'])
         end
 
-        def finished?
+        def ready?
           self.job_status != 0
         end
+
+        def successful?
+          self.job_result_code == 0
+        end
+
+        # so dirty
+        def result
+          if successful? && model = Fog::Compute::Cloudstack.constants.find{|c| c.to_s.downcase == self.job_result.keys.first.to_s}.to_s
+            collection = model.gsub(/.[A-Z]/){|w| "#{w[0]}_#{w[1].downcase}"}.downcase + "s" # cheap underscorize, assume simple pluralization
+            connection.send(collection).new(self.job_result.values.first)
+          else self.job_result
+          end
+        end
       end # Job
     end # Cloudstack
   end # Compute

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

@@ -15,7 +15,7 @@ module Fog
         end
 
         def get(job_id)
-          if job = connection.query_async_job_result('jobid' => job_id)["listasyncjobsresponse"]["asyncjobs"].first
+          if job = connection.query_async_job_result('jobid' => job_id)["queryasyncjobresultresponse"]
             new(job)
           end
         rescue Fog::Compute::Cloudstack::BadRequest

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

@@ -0,0 +1,50 @@
+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
+          connection.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 = connection.create_security_group(options)
+          merge_attributes(data['createsecuritygroupresponse']['securitygroup'])
+        end
+
+        def rules
+          connection.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

@@ -0,0 +1,62 @@
+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 = connection.send("revoke_security_group_#{self.direction}", "id" => self.id)
+          job = connection.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 = connection.send("authorize_security_group_#{self.direction}".to_sym, params)
+          job = connection.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
+          connection.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

@@ -0,0 +1,37 @@
+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
+          connection.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

@@ -0,0 +1,27 @@
+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 = connection.list_security_groups(options)["listsecuritygroupsresponse"]["securitygroup"] || []
+          load(data)
+        end
+
+        def get(security_group_id)
+          if security_group = connection.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

@@ -4,39 +4,54 @@ module Fog
   module Compute
     class Cloudstack
       class Server < Fog::Compute::Server
-        identity  :id,                      :aliases => 'id'
+        identity  :id,                                      :aliases => 'id'
         attribute :name
-        attribute :account
-        attribute :domain
+        attribute :account_name,                            :aliases => 'account'
+        attribute :domain_name,                             :aliases => 'domain'
         attribute :created
         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 :security_group,          :aliases => 'securitygroup'
-        attribute :nics,                    :aliases => 'nic'
+        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 :security_group_list,    :type => :array, :aliases => 'securitygroup'
+        attribute :nics,                   :type => :array, :aliases => 'nic'
 
         attr_accessor :network_ids, :disk_offering_id, :ip_address, :ip_to_network_list
+        attr_writer :security_group_ids
+
+        def addresses
+          nics.map{|nic| Address.new(nic)}
+        end
+
+        def destroy
+          requires :id
+          data = connection.destroy_virtual_machine("id" => id)
+          connection.jobs.new(data["destroyvirtualmachineresponse"])
+        end
+
+        def flavor
+          connection.flavors.get(self.flavor_id)
+        end
 
         def ready?
           state == 'Running'
@@ -45,9 +60,19 @@ module Fog
         def reboot
           requires :id
           data = connection.reboot_virtual_machine('id' => self.id) # FIXME: does this ever fail?
-          job = Job.new(data["rebootvirtualmachineresponse"])
-          job.connection= self.connection
-          job
+          connection.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| self.connection.security_groups.get(id)}
         end
 
         def save
@@ -64,27 +89,26 @@ module Fog
             'hostid'            => host_id,
             'ipaddress'         => ip_address,
             'iptonetworklist'   => ip_to_network_list,
-            'projectid'         => project_id
+            'projectid'         => project_id,
           }
 
           options.merge!('networkids' => network_ids) if network_ids
+          options.merge!('securitygroupids' => security_group_ids) if security_group_ids
 
           data = connection.deploy_virtual_machine(options)
           merge_attributes(data['deployvirtualmachineresponse'])
         end
 
-        def addresses
-          nics.map{|nic| Address.new(nic)}
-        end
-
-        def flavor
-          connection.flavors.get(self.flavor_id)
+        def start
+          requires :id
+          data = connection.start_virtual_machine("id" => self.id)
+          connection.jobs.new(data["startvirtualmachineresponse"])
         end
 
-        def destroy
+        def stop(force=false)
           requires :id
-          connection.destroy_virtual_machine(:id => id)
-          true
+          data = connection.stop_virtual_machine("id" => self.id, "force" => force)
+          connection.jobs.new(data["stopvirtualmachineresponse"])
         end
       end # Server
     end # Cloudstack