fog 1.1.0 → 1.2.0

data/lib/fog/vcloud/models/compute/helpers/status.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Vcloud
+    class Compute
+      module Helpers
+        module Status
+          def friendly_status
+            load_unless_loaded!
+            case status
+              when '0'
+            'creating'
+              when '8'
+            'off'
+              when '4'
+            'on'
+            else
+            'unknown'
+            end
+          end
+
+          def on?
+            reload_status
+            status == '4'
+          end
+
+          def off?
+            reload_status
+            status == '8'
+          end
+
+          def reload_status
+            reload # always ensure we have the correct status
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,9 +3,9 @@ module Fog
     class Compute
       class Ip < Fog::Vcloud::Model
 
-        ignore_attributes :xmlns_i, :xmlns
-
         identity :href, :aliases => :Href
+        attribute :links, :aliases => :Link, :type => :array
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
 
         attribute :name, :aliases => :Name
         attribute :status, :aliases => :Status

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

@@ -3,61 +3,19 @@ module Fog
     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
+        identity :href, :aliases => :Href
         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
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
 
-        def reload
-          super
-          merge_attributes(extension_data.body)
-          self
-        end
-
-        private
-
-        def extension_data
-          connection.get_network_extensions( extensions_link[:href] )
-        end
+        attribute :name, :aliases => :Name
 
-        def extensions_link
-          links.detect { |link| link[:name] == name }
-        end
+        attribute :description, :aliases => :Description
+        attribute :configuration, :aliases => :Configuration
+        attribute :provider_info, :aliases => :ProviderInfo
 
-        def _compose_network_data
-          {
-            :id => id,
-            :href => extension_href,
-            :name => name,
-            :address => address,
-            :broadcast => broadcast,
-            :gateway => gateway
-          }
+        def parent_network
+          return nil if configuration[:ParentNetwork].nil?
+          @parent_network ||= connection.get_network(configuration[:ParentNetwork][:href])
         end
       end
     end

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

@@ -14,20 +14,34 @@ module Fog
 
         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)
+          data = nil
+          if self.href =~ /\/vdc\//
+            check_href!("Vdc")
+            data = [connection.get_vdc(self.href).available_networks].flatten.compact.reject{|n| n == '' }
+          elsif self.href =~ /\/org\//
+            check_href!("Org")
+            data = connection.get_organization(self.href).links.select{|l| l[:type] == network_type_id }
+          elsif self.href =~ /\/vApp\//
+            check_href!("Vapp")
+            data = [(connection.get_vapp(self.href).network_configs||{})[:NetworkConfig]].flatten.compact.collect{|n| n[:Configuration][:ParentNetwork] unless n[:Configuration].nil? }.compact
           end
+          load([*data]) unless data.nil?
         end
 
         def get(uri)
-          if data = connection.get_network(uri)
-            new(data.body)
-          end
-          rescue Fog::Errors::NotFound
+          connection.get_network(uri)
+        rescue Fog::Errors::NotFound
           nil
         end
 
+        private
+        def network_type_id
+          if connection.version == '1.0'
+            'application/vnd.vmware.vcloud.network+xml'
+          else
+            'application/vnd.vmware.vcloud.orgNetwork+xml'
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,43 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Organization < Fog::Vcloud::Model
+
+        identity :href, :aliases => :Href
+        attribute :links, :aliases => :Link, :type => :array
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+        attribute :name
+        attribute :description, :aliases => :Description
+        attribute :type
+        attribute :full_name, :aliases => :FullName
+
+        def networks
+          @networks ||= Fog::Vcloud::Compute::Networks.
+            new( :connection => connection,
+                 :href => href )
+        end
+
+        def tasks
+          load_unless_loaded!
+          @tasks ||= Fog::Vcloud::Compute::Tasks.
+            new( :connection => connection,
+                 :href => other_links.find{|l| l[:type] == 'application/vnd.vmware.vcloud.tasksList+xml'}[:href] )
+        end
+
+        def vdcs
+          @vdcs ||= Fog::Vcloud::Compute::Vdcs.
+            new( :connection => connection,
+                 :href => href )
+        end
+
+        def catalogs
+          @catalogs ||= Fog::Vcloud::Compute::Catalogs.
+            new( :connection => connection,
+                 :href => href )
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/vcloud/models/compute/organization'
+
+module Fog
+  module Vcloud
+    class Compute
+
+      class Organizations < Collection
+
+        model Fog::Vcloud::Compute::Organization
+
+        undef_method :create
+
+        def all
+          raw_orgs = if connection.version == '1.0'
+            connection.login
+          else
+            connection.request(connection.basic_request_params("#{connection.base_path_url}/org/"))
+          end
+          data = raw_orgs.body[:Org].select { |org| org[:type] == "application/vnd.vmware.vcloud.org+xml" }
+          data.each { |org| org.delete_if { |key, value| [:rel].include?(key) } }
+          load(data)
+        end
+
+        def get(uri)
+          connection.get_organization(uri)
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -1,58 +1,57 @@
+require 'fog/vcloud/models/compute/helpers/status'
 module Fog
   module Vcloud
     class Compute
       class Server < Fog::Vcloud::Model
 
-        identity :href, :aliases => :Href
+        include Fog::Vcloud::Compute::Helpers::Status
 
+        identity :href, :aliases => :Href
+        attribute :links, :aliases => :Link, :type => :array
         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 :deployed, :type => :boolean
         attribute :description, :aliases => :Description
-        attribute :storage_size, :aliases => :size
-        attribute :links, :aliases => :Link, :type => :array
+
+        attribute :vapp_scoped_local_id, :aliases => :VAppScopedLocalId
+
+        attribute :network_connections, :aliases => :NetworkConnectionSection, :squash => :NetworkConnection
+        attribute :virtual_hardware, :aliases => :'ovf:VirtualHardwareSection', :squash => :'ovf:Item'
+
+        attribute :guest_customization, :aliases => :GuestCustomizationSection
+        attribute :operating_system, :aliases => :'ovf:OperatingSystemSection'
+
         attribute :tasks, :aliases => :Tasks, :type => :array
 
-        attribute :vm_data, :aliases => :Children, :squash => :Vm
+        has_up :vapp
 
-        def ip_address
+        def computer_name
           load_unless_loaded!
-          vm[0][:NetworkConnectionSection][:NetworkConnection][:IpAddress]
+          self.guest_customization[:ComputerName]
         end
 
-        def friendly_status
+        def os_desc
           load_unless_loaded!
-          case status
-          when '0'
-            'creating'
-          when '8'
-            'off'
-          when '4'
-            'on'
-          else
-            'unkown'
-          end
+          self.operating_system[:'ovf:Description']
         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
+        def os_type
+          load_unless_loaded!
+          self.operating_system[:vmw_osType]
         end
 
-        def on?
-          reload_status # always ensure we have the correct status
-          status == '4'
+        def ip_addresses
+          load_unless_loaded!
+          [self.network_connections].flatten.collect{|n| n[:IpAddress] }
         end
 
-        def off?
+        def ready?
           reload_status # always ensure we have the correct status
-          status == '8'
+          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 power_on
@@ -83,11 +82,6 @@ module Fog
           power_on
         end
 
-        def vm
-          load_unless_loaded!
-          self.vm_data
-        end
-
         def name=(new_name)
           attributes[:name] = new_name
           @changed = true
@@ -120,7 +114,7 @@ module Fog
 
         def disks
           disk_mess.map do |dm|
-            { :number => dm[:"rasd:AddressOnParent"], :size => dm[:"rasd:VirtualQuantity"].to_i, :resource => dm[:"rasd:HostResource"] }
+            { :number => dm[:"rasd:AddressOnParent"].to_i, :size => dm[:"rasd:HostResource"][:vcloud_capacity].to_i, :resource => dm[:"rasd:HostResource"], :disk_data => dm }
           end
         end
 
@@ -187,12 +181,12 @@ module Fog
                 vh[:'rasd:ResourceType'] == '17' &&
                   vh[:'rasd:AddressOnParent'].to_s == @remove_disk.to_s
               end
-              connection.configure_vm_disks(vm_href, data)
+              connection.configure_vm_disks(self.href, data)
             end
             if @disk_change == :added
               data = disk_mess
               data << @add_disk
-              connection.configure_vm_disks(vm_href, data)
+              connection.configure_vm_disks(self.href, data)
             end
             if @name_changed || @description_changed
               edit_uri = links.select {|i| i[:rel] == 'edit'}
@@ -216,14 +210,6 @@ module Fog
         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
@@ -242,29 +228,24 @@ module Fog
           }
         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" }
+          if virtual_hardware
+            virtual_hardware.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" }
+          if virtual_hardware
+            virtual_hardware.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" }
+          if virtual_hardware
+            virtual_hardware.select { |item| item[:"rasd:ResourceType"] == "17" }
           else
             []
           end
@@ -282,9 +263,8 @@ module Fog
         end
 
         def reload_status
-          self.status = connection.get_vapp(href).body[:status]
+          self.status = connection.get_vapp(href).status
         end
-
       end
     end
   end

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

@@ -13,16 +13,13 @@ module Fog
         attribute :href, :aliases => :Href
 
         def all
-          check_href!(:parent => "Vdc")
-          load(_vapps)
+          check_href!("Vapp")
+          vapp.load_unless_loaded!
+          load(vapp.children||[])
         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
+          connection.get_vapp(uri)
         rescue Fog::Errors::NotFound
           nil
         end
@@ -37,19 +34,16 @@ module Fog
 
         private
 
-        def _resource_entities
-          if Hash === resource_entities = connection.get_vdc(href).body[:ResourceEntities]
-            resource_entities[:ResourceEntity]
-          end
+        def vapp
+          @vapp ||= (attributes[:vapp] || init_vapp)
         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
+        def init_vapp
+          Fog::Vcloud::Compute::Vapp.new(
+            :connection => connection,
+            :href => self.href,
+            :collection => Fog::Vcloud::Compute::Vapps.new(:connection => connection)
+          )
         end
 
       end

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

@@ -4,7 +4,7 @@ module Fog
       class Task < Fog::Vcloud::Model
 
         identity :href, :aliases => :Href
-
+        attribute :links, :aliases => :Link, :type => :array
         ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
 
         attribute :status

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

@@ -19,9 +19,7 @@ module Fog
         end
 
         def get(uri)
-          if data = connection.get_task(uri)
-            new(data.body)
-          end
+          connection.get_task(uri)
         rescue Fog::Errors::NotFound
           nil
         end

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

@@ -0,0 +1,43 @@
+require 'fog/vcloud/models/compute/helpers/status'
+module Fog
+  module Vcloud
+    class Compute
+      class Vapp < Fog::Vcloud::Model
+
+        include Fog::Vcloud::Compute::Helpers::Status
+
+        identity :href, :aliases => :Href
+        attribute :links, :aliases => :Link, :type => :array
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+        attribute :name
+        attribute :type
+        attribute :status
+        attribute :description, :aliases => :Description
+        attribute :deployed, :type => :boolean
+
+        attribute :children, :aliases => :Children, :squash => :Vm
+        attribute :lease_settings, :aliases => :LeaseSettingsSection
+
+        attribute :network_configs, :aliases => :NetworkConfigSection
+
+        has_up :vdc
+
+        def servers
+          @servers ||= Fog::Vcloud::Compute::Servers.
+            new( :connection => connection,
+                 :href => href,
+                 :vapp => self
+            )
+        end
+
+        def networks
+          @networks ||= Fog::Vcloud::Compute::Networks.
+            new( :connection => connection,
+                 :href => href
+            )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/vcloud/models/compute/vapp'
+
+module Fog
+  module Vcloud
+    class Compute
+
+      class Vapps < Collection
+
+        model Fog::Vcloud::Compute::Vapp
+
+        undef_method :create
+
+        attribute :href
+
+        def all
+          load([connection.get_vdc(self.href).resource_entities].flatten.select { |re| re[:type] == "application/vnd.vmware.vcloud.vApp+xml" })
+        end
+
+        def get(uri)
+          connection.get_vapp(uri)
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -3,20 +3,24 @@ module Fog
     class Compute
       class Vdc < Fog::Vcloud::Model
 
-        identity :href
-
-        ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
+        identity :href, :aliases => :Href
+        attribute :links, :aliases => :Link, :type => :array
+        ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
 
         attribute :name
         attribute :type
         attribute :description, :aliases => :Description
-        attribute :other_links, :aliases => :Link
+        attribute :network_quota, :aliases => :NetworkQuota, :type => :integer
+        attribute :nic_quota, :aliases => :NicQuota, :type => :integer
+        attribute :vm_quota, :aliases => :VmQuota, :type => :integer
+        attribute :is_enabled, :aliases => :IsEnabled, :type => :boolean
         attribute :compute_capacity, :aliases => :ComputeCapacity
         attribute :storage_capacity, :aliases => :StorageCapacity
         attribute :available_networks, :aliases => :AvailableNetworks, :squash => :Network
+
         attribute :resource_entities, :aliases => :ResourceEntities, :squash => :ResourceEntity
-        attribute :deployed_vm_quota
-        attribute :instantiated_vm_quota
+
+        has_up :organization
 
         def networks
           @networks ||= Fog::Vcloud::Compute::Networks.
@@ -24,32 +28,13 @@ module Fog
                  :href => href )
         end
 
-        def servers
-          @servers ||= Fog::Vcloud::Compute::Servers.
+        def vapps
+          @vapps ||= Fog::Vcloud::Compute::Vapps.
             new( :connection => connection,
-                 :href => href )
+                 :href => href
+            )
         end
 
-        def tasks
-          @tasks ||= Fog::Vcloud::Compute::Tasks.
-            new( :connection => connection,
-                 :href => href + "/tasksList" )
-        end
-
-        private
-
-        def collection_based_on_type(type, klass = nil)
-          load_unless_loaded!
-          test_links = other_links.kind_of?(Array) ? other_links : [other_links]
-          if link = test_links.detect { |link| link[:type] == type }
-            case type
-            when "application/vnd.vmware.vcloud.catalog+xml"
-              Fog::Vcloud::Compute::Catalog
-            end.new( :connection => connection, :href => link[:href] )
-          else
-            [ ]
-          end
-        end
       end
     end
   end

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

@@ -10,30 +10,25 @@ module Fog
 
         undef_method :create
 
+        attribute :href
+
         def all
-          data = connection.get_organization(organization_uri).body[:Link].select { |link| link[:type] == "application/vnd.vmware.vcloud.vdc+xml" }
+          data = connection.get_organization(org_uri).links.select { |link| link[:type] == "application/vnd.vmware.vcloud.vdc+xml" }
           data.each { |link| link.delete_if { |key, value| [:rel].include?(key) } }
           load(data)
         end
 
         def get(uri)
-          if data = connection.get_vdc(uri)
-            new(data.body)
-          end
+          connection.get_vdc(uri)
         rescue Fog::Errors::NotFound
           nil
         end
 
-        def organization_uri
-          @organization_uri ||= connection.default_organization_uri
-        end
-
         private
 
-        def organization_uri=(new_organization_uri)
-          @organization_uri = new_organization_uri
+        def org_uri
+          self.href ||= connection.default_organization_uri
         end
-
       end
     end
   end