fog 0.2.0 → 0.2.1

data/lib/fog/vcloud/terremark/ecloud/models/ips.rb

@@ -9,24 +9,20 @@ module Fog
 
           undef_method :create
 
-          def all
-            load(connection.get_network_ips(href).body.addresses.
-                 map { |address| { :name => address.name, :status => address.status, :server => address.server } })
-          end
-
-          def get_raw(name)
-            raw_results.detect { |address| address.name == name }
-          end
+          attribute :href
 
-          def reload
-            super
-            @raw_results = nil
+          def all
+            if data = connection.get_network_ips(href).body[:IpAddress]
+              load(data)
+            end
           end
 
-          private
-
-          def raw_results
-            @raw_results ||= connection.get_network_ips(href).body.addresses
+          def get(uri)
+            if data = connection.get_network_ip(uri).body
+              new(data)
+            end
+          rescue Fog::Errors::NotFound
+            nil
           end
 
         end

data/lib/fog/vcloud/terremark/ecloud/models/network.rb

@@ -1,5 +1,3 @@
-require 'fog/model'
-
 module Fog
   module Vcloud
     module Terremark
@@ -8,20 +6,63 @@ module Fog
 
           identity :href
 
-          attribute :name
-          attribute :features
-          attribute :configuration
-          attribute :ips_link
+          ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd, :xmlns_i, :Configuration
+
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
+          attribute :features, :aliases => :Features, :type => :array
+          attribute :links, :aliases => :Link, :type => :array
           attribute :type
-          attribute :xmlns
+          attribute :gateway, :aliases => :GatewayAddress
+          attribute :broadcast, :aliases => :BroadcastAddress
+          attribute :address, :aliases => :Address
+          attribute :rnat, :aliases => :RnatAddress
+          attribute :extension_href, :aliases => :Href
 
           def ips
-            unless @loaded
-              reload
-            end
+            load_unless_loaded!
             @ips ||= Fog::Vcloud::Terremark::Ecloud::Ips.
               new( :connection => connection,
-                   :href => ips_link.href )
+                   :href => links.detect { |link| link[:name] == "IP Addresses" }[:href] )
+          end
+
+          def rnat=(new_rnat)
+            @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)
+          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

data/lib/fog/vcloud/terremark/ecloud/models/networks.rb

@@ -3,12 +3,6 @@ module Fog
     module Terremark
       module Ecloud
 
-        module Mock
-          def networks(options = {})
-            @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.new(options.merge(:connection => self))
-          end
-        end
-
         module Real
           def networks(options = {})
             @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.new(options.merge(:connection => self))
@@ -21,14 +15,21 @@ module Fog
 
           model Fog::Vcloud::Terremark::Ecloud::Network
 
-          get_request :get_network
-          vcloud_type "application/vnd.vmware.vcloud.network+xml"
-          all_request lambda { |networks| networks.connection.get_vdc(networks.href).body.networks }
+          attribute :href
+
+          def all
+            if data = connection.get_vdc(href).body[:AvailableNetworks][:Network]
+              load(data)
+            end
+          end
 
-          #def all
-          #  pp connection.get_vdc(href).body.networks
-          #  load(connection.get_vdc(href).body.networks.map { |network| { } } )
-          #end
+          def get(uri)
+            if data = connection.get_network(uri)
+              new(data.body)
+            end
+            rescue Fog::Errors::NotFound
+            nil
+          end
 
         end
       end

data/lib/fog/vcloud/terremark/ecloud/models/node.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Node < Fog::Vcloud::Model
+
+          identity :href, :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
+end
+
+

data/lib/fog/vcloud/terremark/ecloud/models/nodes.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class Nodes < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::Node
+
+          attribute :href, :aliases => :Href
+
+          def all
+            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
+end

data/lib/fog/vcloud/terremark/ecloud/models/public_ip.rb

@@ -1,21 +1,18 @@
-require 'fog/model'
-
 module Fog
   module Vcloud
     module Terremark
       module Ecloud
         class PublicIp < Fog::Vcloud::Model
 
-          identity :href
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i
 
-          attribute :name
-          attribute :type
-          attribute :id
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
 
           def internet_services
-            unless @loaded
-              reload
-            end
+            load_unless_loaded!
             @internet_services ||= Fog::Vcloud::Terremark::Ecloud::InternetServices.
               new( :connection => connection,
                    :href => href.to_s + "/internetServices" )

data/lib/fog/vcloud/terremark/ecloud/models/public_ips.rb

@@ -19,11 +19,27 @@ module Fog
 
           undef_method :create
 
+          attribute :href, :aliases => :Href
+
           model Fog::Vcloud::Terremark::Ecloud::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) }
+          #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
+            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

data/lib/fog/vcloud/terremark/ecloud/models/server.rb

@@ -0,0 +1,203 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Server < Fog::Vcloud::Model
+
+          identity :href, :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, :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)
+            @name = new_name
+            @changed = true
+          end
+
+          def cpus
+            { :count => cpu_mess[:VirtualQuantity].to_i,
+              :units => cpu_mess[:AllocationUnits] }
+          end
+
+          def cpus=(qty)
+            @changed = true
+            cpu_mess[:VirtualQuantity] = qty.to_s
+          end
+
+          def memory
+            { :amount => memory_mess[:VirtualQuantity].to_i,
+              :units => memory_mess[:VirtualQuantityUnits] }
+          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
+            super
+            reset_tracking
+          end
+
+          def save
+            if new_record?
+              requires :name
+              puts "NOOP"
+              return false
+              #result = connection.instantiate_vapp_template( stuff )
+              #merge_attributes(result.body)
+            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
+            true
+          end
+
+          def _compose_vapp_data
+            { :name   => name,
+              :cpus   => cpus[:count],
+              :memory => memory[:amount],
+              :disks  => disks
+            }
+          end
+
+          def memory_mess
+            load_unless_loaded!
+            virtual_hardware[:Item].detect { |item| item[:ResourceType] == "4" }
+          end
+
+          def cpu_mess
+            load_unless_loaded!
+            virtual_hardware[:Item].detect { |item| item[:ResourceType] == "3" }
+          end
+
+          def disk_mess
+            load_unless_loaded!
+            virtual_hardware[:Item].select { |item| item[:ResourceType] == "17" }
+          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 on/
+            end
+            true
+          end
+
+        end
+      end
+    end
+  end
+end