fog 0.5.3 → 0.6.0

data/lib/fog/compute/models/ecloud/internet_services.rb

@@ -0,0 +1,33 @@
+require 'fog/compute/models/ecloud/internet_service'
+
+module Fog
+  module Ecloud
+    class Compute
+      class InternetServices < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::InternetService
+
+        attribute :href, :aliases => :Href
+
+        def all
+          check_href! :message => "the Internet Services for the Vdc you want to enumerate"
+          if internet_service_data = connection.get_internet_services(href).body[:InternetService]
+            load(Array[internet_service_data].flatten.find_all {|i| i[:IsBackupService] == "false" })
+          end
+        end
+
+        # Optimize later, no need to get_internet_services again?
+        def get(uri)
+          internet_services = connection.get_internet_services(href).body[:InternetService]
+          internet_services = [ internet_services ] if internet_services.is_a?(Hash)
+          if data = internet_services.detect { |service| service[:Href] == uri }
+            new(data)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/models/ecloud/ip.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Ip < Fog::Ecloud::Model
+
+        ignore_attributes :xmlns_i, :xmlns
+
+        identity :href, :aliases => :Href
+
+        attribute :name, :aliases => :Name
+        attribute :status, :aliases => :Status
+        attribute :server, :aliases => :Server
+        attribute :rnat, :aliases => :RnatAddress
+        attribute :id, :aliases => :Id, :type => :integer
+
+        def rnat=(new_rnat)
+          attributes[:rnat] = new_rnat
+          @changed = true
+        end
+
+        def save
+          if @changed
+            connection.configure_network_ip( href, _compose_network_ip_data )
+          end
+          true
+        end
+
+        def reload
+          super
+          @changed = false
+          self
+        end
+
+        private
+        def _compose_network_ip_data
+          {
+            :id => id,
+            :href => href,
+            :name => name,
+            :status => status,
+            :server => server,
+            :rnat => rnat
+          }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/compute/models/ecloud/ip'
+
+module Fog
+  module Ecloud
+    class Compute
+      class Ips < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::Ip
+
+        undef_method :create
+
+        attribute :href
+
+        def all
+          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/ecloud/network.rb

@@ -0,0 +1,72 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Network < Fog::Ecloud::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 :rnat, :aliases => :RnatAddress
+        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::Ecloud::Compute::Ips.new( :connection => connection,
+               :href => links.detect { |link| link[:name] == "IP Addresses" }[:href] )
+        end
+
+        def rnat=(new_rnat)
+          attributes[:rnat] = new_rnat
+          @changed = true
+        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,
+            :rnat => rnat,
+            :address => address,
+            :broadcast => broadcast,
+            :gateway => gateway
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/compute/models/ecloud/network'
+
+module Fog
+  module Ecloud
+    class Compute
+
+      class Networks < Fog::Ecloud::Collection
+
+        undef_method :create
+
+        model Fog::Ecloud::Compute::Network
+
+        attribute :href
+
+        def all
+          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/ecloud/node.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Node < Fog::Ecloud::Model
+
+        identity :href, :aliases => :Href
+
+        ignore_attributes :xmlns, :xmlns_i
+
+        attribute :ip_address, :aliases => :IpAddress
+        attribute :description, :aliases => :Description
+        attribute :name, :aliases => :Name
+        attribute :port, :aliases => :Port
+        attribute :enabled, :aliases => :Enabled
+        attribute :id, :aliases => :Id
+
+        def delete
+          requires :href
+
+          connection.delete_node( href )
+        end
+
+        def save
+          if new_record?
+            result = connection.add_node( collection.href, _compose_node_data )
+            merge_attributes(result.body)
+          else
+            connection.configure_node( href, _compose_node_data )
+          end
+        end
+
+        private
+
+        def _compose_node_data
+          node_data = {}
+          self.class.attributes.select{ |attribute| !send(attribute).nil? }.each { |attribute| node_data[attribute] = send(attribute).to_s }
+          node_data
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/models/ecloud/nodes.rb

@@ -0,0 +1,31 @@
+require 'fog/compute/models/ecloud/node'
+
+module Fog
+  module Ecloud
+    class Compute
+
+      class Nodes < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::Node
+
+        attribute :href, :aliases => :Href
+
+        def all
+          check_href!( :messages => "the Nodes href of the Internet Service you want to enumerate" )
+          if data = connection.get_nodes(href).body[:NodeService]
+            load(data)
+          end
+        end
+
+        def get(uri)
+          if data = connection.get_node(uri)
+            new(data.body)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/models/ecloud/public_ip.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Ecloud
+    class Compute
+      class PublicIp < Fog::Ecloud::Model
+
+        identity :href, :aliases => :Href
+
+        ignore_attributes :xmlns, :xmlns_i
+
+        attribute :name, :aliases => :Name
+        attribute :id, :aliases => :Id
+
+        def internet_services
+          load_unless_loaded!
+          @internet_services ||= Fog::Ecloud::Compute::InternetServices.
+            new( :connection => connection,
+                 :href => href.to_s + "/internetServices" )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/ecloud/public_ips.rb

@@ -0,0 +1,36 @@
+require 'fog/compute/models/ecloud/public_ip'
+
+module Fog
+  module Ecloud
+    class Compute
+      class PublicIps < Fog::Ecloud::Collection
+
+        undef_method :create
+
+        attribute :href, :aliases => :Href
+
+        model Fog::Ecloud::Compute::PublicIp
+
+        #get_request :get_public_ip
+        #vcloud_type "application/vnd.tmrk.ecloud.publicIp+xml"
+        #all_request lambda { |public_ips| public_ips.connection.get_public_ips(public_ips.href) }
+
+        def all
+          check_href!(:message => "the Public Ips href of the Vdc you want to enumerate")
+          if data = connection.get_public_ips(href).body[:PublicIPAddress]
+            load(data)
+          end
+        end
+
+        def get(uri)
+          if data = connection.get_public_ip(uri)
+            new(data.body)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Server < Fog::Ecloud::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 :storage_size, :aliases => :size
+        attribute :links, :aliases => :Link, :type => :array
+
+        def friendly_status
+          load_unless_loaded!
+          case status
+          when '0'
+            'creating'
+          when '2'
+            'off'
+          when '4'
+            'on'
+          else
+            'unkown'
+          end
+        end
+
+        def ready?
+          load_unless_loaded!
+          status == '2'
+        end
+
+        def on?
+          load_unless_loaded!
+          status == '4'
+        end
+
+        def off?
+          load_unless_loaded!
+          status == '2'
+        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
+
+        def graceful_restart
+          requires :href
+          shutdown
+          wait_for { off? }
+          power_on
+        end
+
+        def delete
+          requires :href
+          connection.delete_vapp( href)
+        end
+
+        def name=(new_name)
+          attributes[:name] = new_name
+          @changed = true
+        end
+
+        def cpus
+          if cpu_mess
+            { :count => cpu_mess[:VirtualQuantity].to_i,
+              :units => cpu_mess[:AllocationUnits] }
+          end
+        end
+
+        def cpus=(qty)
+          @changed = true
+          cpu_mess[:VirtualQuantity] = qty.to_s
+        end
+
+        def memory
+          if memory_mess
+            { :amount => memory_mess[:VirtualQuantity].to_i,
+              :units => memory_mess[:AllocationUnits] }
+          end
+        end
+
+        def memory=(amount)
+          @changed = true
+          memory_mess[:VirtualQuantity] = amount.to_s
+        end
+
+        def disks
+          disk_mess.map do |dm|
+            { :number => dm[:AddressOnParent], :size => dm[:VirtualQuantity].to_i, :resource => dm[: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
+            @disk_change = :added
+            load_unless_loaded!
+            virtual_hardware[:Item] << { :ResourceType => '17',
+                                         :AddressOnParent => (disk_mess.map { |dm| dm[:AddressOnParent] }.sort.last.to_i + 1).to_s,
+                                         :VirtualQuantity => size.to_s }
+          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
+            @disk_change = :deleted
+            load_unless_loaded!
+            unless number == 0
+              virtual_hardware[:Item].delete_if { |vh| vh[:ResourceType] == '17' && vh[:AddressOnParent].to_i == number }
+            end
+          end
+          true
+        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
+            connection.configure_vapp( href, _compose_vapp_data )
+          end
+          reset_tracking
+        end
+
+        private
+
+        def reset_tracking
+          @disk_change = false
+          @changed = false
+        end
+
+        def _compose_vapp_data
+          { :name   => name,
+            :cpus   => cpus[:count],
+            :memory => memory[:amount],
+            :disks  => disks
+          }
+        end
+
+        def memory_mess
+          load_unless_loaded!
+          if virtual_hardware && virtual_hardware[:Item]
+            virtual_hardware[:Item].detect { |item| item[:ResourceType] == "4" }
+          end
+        end
+
+        def cpu_mess
+          load_unless_loaded!
+          if virtual_hardware && virtual_hardware[:Item]
+            virtual_hardware[:Item].detect { |item| item[:ResourceType] == "3" }
+          end
+        end
+
+        def disk_mess
+          load_unless_loaded!
+          if virtual_hardware && virtual_hardware[:Item]
+            virtual_hardware[:Item].select { |item| item[: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
+
+      end
+    end
+  end
+end