fog 0.9.0 → 0.10.0

data/lib/fog/compute/models/vcloud/ips.rb

@@ -0,0 +1,33 @@
+require 'fog/compute/models/vcloud/ip'
+
+module Fog
+  module Vcloud
+    class Compute
+      class Ips < Fog::Vcloud::Collection
+
+        model Fog::Vcloud::Compute::Ip
+
+        undef_method :create
+
+        attribute :href
+
+        def all
+          self.href = connection.default_vdc_href unless self.href
+          check_href!( :messages => "Ips href of a Network you want to enumerate" )
+          if data = connection.get_network_ips(href).body[:IpAddress]
+            load(data)
+          end
+        end
+
+        def get(uri)
+          if data = connection.get_network_ip(uri).body
+            new(data)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Network < Fog::Vcloud::Model
+
+        identity :href
+
+        ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd, :xmlns_i, :Configuration, :Id
+
+        attribute :name, :aliases => :Name
+        #attribute :id, :aliases => :Id
+        attribute :features, :aliases => :Features, :type => :array
+        attribute :links, :aliases => :Link, :type => :array
+        attribute :type
+        attribute :gateway, :aliases => :GatewayAddress
+        attribute :broadcast, :aliases => :BroadcastAddress
+        attribute :address, :aliases => :Address
+        attribute :extension_href, :aliases => :Href
+        attribute :network_type, :aliases => :NetworkType
+        attribute :vlan, :aliases => :Vlan
+        attribute :friendly_name, :aliases => :FriendlyName
+
+        def ips
+          load_unless_loaded!
+          Fog::Vcloud::Compute::Ips.new( :connection => connection,
+               :href => links.detect { |link| link[:name] == "IP Addresses" }[:href] )
+        end
+
+        def save
+          if @changed
+            connection.configure_network( extension_href, _compose_network_data )
+          end
+          true
+        end
+
+        def reload
+          super
+          merge_attributes(extension_data.body)
+          self
+        end
+
+        private
+
+        def extension_data
+          connection.get_network_extensions( extensions_link[:href] )
+        end
+
+        def extensions_link
+          links.detect { |link| link[:name] == name }
+        end
+
+        def _compose_network_data
+          {
+            :id => id,
+            :href => extension_href,
+            :name => name,
+            :address => address,
+            :broadcast => broadcast,
+            :gateway => gateway
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/compute/models/vcloud/network'
+
+module Fog
+  module Vcloud
+    class Compute
+
+      class Networks < Fog::Vcloud::Collection
+
+        undef_method :create
+
+        model Fog::Vcloud::Compute::Network
+
+        attribute :href
+
+        def all
+          self.href = connection.default_vdc_href unless self.href
+          check_href!("Vdc")
+          if data = connection.get_vdc(href).body[:AvailableNetworks][:Network]
+            load(data)
+          end
+        end
+
+        def get(uri)
+          if data = connection.get_network(uri)
+            new(data.body)
+          end
+          rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,291 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Server < Fog::Vcloud::Model
+
+        identity :href, :aliases => :Href
+
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+        attribute :type
+        attribute :name
+        attribute :status
+        attribute :network_connections, :aliases => :NetworkConnectionSection, :squash => :NetworkConnection
+        attribute :os, :aliases => :OperatingSystemSection
+        attribute :virtual_hardware, :aliases => :VirtualHardwareSection
+        attribute :description, :aliases => :Description
+        attribute :storage_size, :aliases => :size
+        attribute :links, :aliases => :Link, :type => :array
+        attribute :tasks, :aliases => :Tasks, :type => :array
+
+        attribute :vm_data, :aliases => :Children, :squash => :Vm
+
+        def ip_address
+          load_unless_loaded!
+          vm[0][:NetworkConnectionSection][:NetworkConnection][:IpAddress]
+        end
+
+        def friendly_status
+          load_unless_loaded!
+          case status
+          when '0'
+            'creating'
+          when '8'
+            'off'
+          when '4'
+            'on'
+          else
+            'unkown'
+          end
+        end
+
+        def ready?
+          reload_status # always ensure we have the correct status
+          running_tasks = tasks && tasks.flatten.any? {|ti| ti.kind_of?(Hash) && ti[:status] == 'running' }
+          status != '0' && !running_tasks # 0 is provisioning, and no running tasks
+        end
+
+        def on?
+          reload_status # always ensure we have the correct status
+          status == '4'
+        end
+
+        def off?
+          reload_status # always ensure we have the correct status
+          status == '8'
+        end
+
+        def power_on
+          power_operation( :power_on => :powerOn )
+        end
+
+        def power_off
+          power_operation( :power_off => :powerOff )
+        end
+
+        def shutdown
+          power_operation( :power_shutdown => :shutdown )
+        end
+
+        def power_reset
+          power_operation( :power_reset => :reset )
+        end
+
+        # This is the real power-off operation
+        def undeploy
+          connection.undeploy href
+        end
+
+        def graceful_restart
+          requires :href
+          shutdown
+          wait_for { off? }
+          power_on
+        end
+
+        def vm
+          load_unless_loaded!
+          self.vm_data
+        end
+
+        def name=(new_name)
+          attributes[:name] = new_name
+          @changed = true
+        end
+
+        def cpus
+          if cpu_mess
+            { :count => cpu_mess[:"rasd:VirtualQuantity"].to_i,
+              :units => cpu_mess[:"rasd:AllocationUnits"] }
+          end
+        end
+
+        def cpus=(qty)
+          @changed = true
+          cpu_mess[:"rasd:VirtualQuantity"] = qty.to_s
+        end
+
+        def memory
+          if memory_mess
+            { :amount => memory_mess[:"rasd:VirtualQuantity"].to_i,
+              :units => memory_mess[:"rasd:AllocationUnits"] }
+          end
+        end
+
+        def memory=(amount)
+          @changed = true
+          @update_memory_value = amount
+          amount
+        end
+
+        def disks
+          disk_mess.map do |dm|
+            { :number => dm[:"rasd:AddressOnParent"], :size => dm[:"rasd:VirtualQuantity"].to_i, :resource => dm[:"rasd:HostResource"] }
+          end
+        end
+
+        def add_disk(size)
+          if @disk_change == :deleted
+            raise RuntimeError, "Can't add a disk w/o saving changes or reloading"
+          else
+            load_unless_loaded!
+            @disk_change = :added
+
+            @add_disk = {
+              :'rasd:HostResource' => {:vcloud_capacity => size},
+              :'rasd:AddressOnParent' =>  (disk_mess.map { |dm| dm[:'rasd:AddressOnParent'] }.sort.last.to_i + 1).to_s,
+              :'rasd:ResourceType' => '17'
+            }
+          end
+          true
+        end
+
+        def delete_disk(number)
+          if @disk_change == :added
+            raise RuntimeError, "Can't delete a disk w/o saving changes or reloading"
+          else
+            load_unless_loaded!
+            unless number == 0
+              @disk_change = :deleted
+              @remove_disk = number
+            end
+          end
+          true
+        end
+
+        def description=(description)
+          @description_changed = true unless attributes[:description] == description || attributes[:description] == nil
+          attributes[:description] = description
+        end
+
+        def name=(name)
+          @name_changed = true unless attributes[:name] == name || attributes[:name] == nil
+          attributes[:name] = name
+        end
+
+        def reload
+          reset_tracking
+          super
+        end
+
+        def save
+          if new_record?
+            #Lame ...
+            raise RuntimeError, "Should not be here"
+          else
+            if on?
+              if @changed
+                raise RuntimeError, "Can't save cpu, name or memory changes while the VM is on."
+              end
+            end
+            if @update_memory_value
+              memory_mess[:"rasd:VirtualQuantity"] = @update_memory_value.to_s
+              connection.configure_vm_memory(memory_mess)
+            end
+            if @disk_change == :deleted
+              data = disk_mess.delete_if do |vh|
+                vh[:'rasd:ResourceType'] == '17' &&
+                  vh[:'rasd:AddressOnParent'].to_s == @remove_disk.to_s
+              end
+              connection.configure_vm_disks(vm_href, data)
+            end
+            if @disk_change == :added
+              data = disk_mess
+              data << @add_disk
+              connection.configure_vm_disks(vm_href, data)
+            end
+            if @name_changed || @description_changed
+              edit_uri = links.select {|i| i[:rel] == 'edit'}
+              edit_uri = edit_uri.kind_of?(Array) ? edit_uri.flatten[0][:href] : edit_uri[:href]
+              connection.configure_vm_name_description(edit_uri, self.name, self.description)
+            end
+          end
+          reset_tracking
+          true
+        end
+
+        def destroy
+          if on?
+            undeploy
+            wait_for { off? }
+          end
+          wait_for { off? } # be sure..
+          wait_for { ready? } # be doubly sure..
+          sleep 2 # API lies. need to give it some time to be happy.
+          connection.delete_vapp(href).body[:status] == "running"
+        end
+        alias :delete :destroy
+
+        def vm_href
+          load_unless_loaded!
+          #require 'pp'
+          #pp vm_data
+          #vm_data[0][:Link].select {|v| v[:rel] == 'edit'}[0][:href]
+          vm_data.kind_of?(Array)? vm_data[0][:href] : vm_data[:href]
+        end
+
+        private
+
+        def reset_tracking
+          @disk_change = false
+          @changed = false
+          @update_memory_value = nil
+          @name_changed = false
+          @description_changed = nil
+        end
+
+        def _compose_vapp_data
+          { :name   => name,
+            :cpus   => cpus[:count],
+            :memory => memory[:amount],
+            :disks  => disks
+          }
+        end
+
+        def virtual_hardware_section
+          load_unless_loaded!
+          vm[0][:"ovf:VirtualHardwareSection"][:"ovf:Item"]
+        end
+
+        def memory_mess
+          load_unless_loaded!
+          if virtual_hardware_section
+            virtual_hardware_section.detect { |item| item[:"rasd:ResourceType"] == "4" }
+          end
+        end
+
+        def cpu_mess
+          load_unless_loaded!
+          if virtual_hardware_section
+            virtual_hardware_section.detect { |item| item[:"rasd:ResourceType"] == "3" }
+          end
+        end
+
+        def disk_mess
+          load_unless_loaded!
+          if virtual_hardware_section
+            virtual_hardware_section.select { |item| item[:"rasd:ResourceType"] == "17" }
+          else
+            []
+          end
+        end
+
+        def power_operation(op)
+          requires :href
+          begin
+            connection.send(op.keys.first, href + "/power/action/#{op.values.first}" )
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered o(n|ff)/
+          end
+          true
+        end
+
+        def reload_status
+          self.status = connection.get_vapp(href).body[:status]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'fog/compute/models/vcloud/server'
+
+module Fog
+  module Vcloud
+    class Compute
+
+      class Servers < Fog::Vcloud::Collection
+
+        undef_method :create
+
+        model Fog::Vcloud::Compute::Server
+
+        attribute :href, :aliases => :Href
+
+        def all
+          check_href!(:parent => "Vdc")
+          load(_vapps)
+        end
+
+        def get(uri)
+          if data = connection.get_vapp(uri)
+            # If no tasks returned, set a mock entry to flush on reload
+            data.body[:Tasks] = {} unless data.body[:Tasks]
+            new(data.body)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def create options
+          check_href!
+          options[:vdc_uri] = href
+          data = connection.instantiate_vapp_template(options).body
+          object = new(data)
+          object
+        end
+
+        private
+
+        def _resource_entities
+          if Hash === resource_entities = connection.get_vdc(href).body[:ResourceEntities]
+            resource_entities[:ResourceEntity]
+          end
+        end
+
+        def _vapps
+          resource_entities = _resource_entities
+          if resource_entities.nil?
+            []
+          else
+            resource_entities.select {|re| re[:type] == 'application/vnd.vmware.vcloud.vApp+xml' }
+          end
+        end
+
+      end
+    end
+  end
+end