fog 0.5.3 → 0.6.0

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

@@ -1,77 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        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 :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!
-            @ips ||= Fog::Vcloud::Terremark::Ecloud::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
-end
-
-

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

@@ -1,36 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/network'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Networks < Fog::Vcloud::Collection
-
-          undef_method :create
-
-          model Fog::Vcloud::Terremark::Ecloud::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
-end
-

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

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

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

@@ -1,33 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/node'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Nodes < Fog::Vcloud::Collection
-
-          model Fog::Vcloud::Terremark::Ecloud::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
-end

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

@@ -1,25 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        class PublicIp < Fog::Vcloud::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::Vcloud::Terremark::Ecloud::InternetServices.
-              new( :connection => connection,
-                   :href => href.to_s + "/internetServices" )
-          end
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,39 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/public_ip'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class PublicIps < Fog::Vcloud::Collection
-
-          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) }
-
-          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
-end

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

@@ -1,211 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        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 :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
-end