fog 0.9.0 → 0.10.0

data/lib/fog/compute/requests/storm_on_demand/reboot_server.rb

@@ -6,7 +6,7 @@ module Fog
         def reboot_server(options = {})
           request(
             :path     => "/storm/server/reboot",
-            :body     => {:params => options}.to_json
+            :body     => MultiJson.encode({:params => options})
           )
         end
 

data/lib/fog/compute/requests/storm_on_demand/remove_balancer_node.rb

@@ -6,7 +6,7 @@ module Fog
         def remove_balancer_node(options = {})
           request(
             :path     => "/network/loadbalancer/removenode",
-            :body     => {:params => options}.to_json
+            :body     => MultiJson.encode({:params => options})
           )
         end
 

data/lib/fog/compute/requests/storm_on_demand/resize_server.rb

@@ -6,7 +6,7 @@ module Fog
         def resize_server(options = {})
           request(
             :path     => "/storm/server/resize",
-            :body     => {:params => options}.to_json
+            :body     => MultiJson.encode({:params => options})
           )
         end
 

data/lib/fog/compute/requests/vcloud/clone_vapp.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Real
+
+        def validate_clone_vapp_options(options)
+          valid_opts = [:name, :poweron]
+          unless valid_opts.all? { |opt| options.keys.include?(opt) }
+            raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
+          end
+        end
+
+        def generate_clone_vapp_request(uri, options)
+          xml = Builder::XmlMarkup.new
+          xml.CloneVAppParams(xmlns.merge!(:name => options[:name], :deploy => "true", :powerOn => options[:poweron])) {
+            xml.VApp( :href => uri, :type => "application/vnd.vmware.vcloud.vApp+xml",
+                      :xmlns => "http://www.vmware.com/vcloud/v0.8")
+          }
+        end
+
+        def clone_vapp(vdc_uri, vapp_uri, options = {})
+          unless options.has_key?(:poweron)
+            options[:poweron] = "false"
+          end
+
+          validate_clone_vapp_options(options)
+
+          request(
+            :body     => generate_clone_vapp_request(vapp_uri, options),
+            :expects  => 202,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.cloneVAppParams+xml'},
+            :method   => 'POST',
+            :uri      => vdc_uri + '/action/clonevapp',
+            :parse    => true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/configure_network.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Real
+
+        def validate_network_data(network_data, configure=false)
+          valid_opts = [:id, :href, :name, :address, :broadcast, :gateway]
+          unless valid_opts.all? { |opt| network_data.keys.include?(opt) }
+            raise ArgumentError.new("Required data missing: #{(valid_opts - network_data.keys).map(&:inspect).join(", ")}")
+          end
+        end
+
+        def configure_network(network_uri, network_data)
+          validate_network_data(network_data)
+
+          request(
+            :body     => generate_configure_network_request(network_data),
+            :expects  => 200,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.networkService+xml'},
+            :method   => 'PUT',
+            :uri      => network_uri,
+            :parse    => true
+          )
+        end
+
+        private
+
+        def generate_configure_network_request(network_data)
+          builder = Builder::XmlMarkup.new
+          builder.Network(xmlns) {
+            builder.Id(network_data[:id])
+            builder.Href(network_data[:href])
+            builder.Name(network_data[:name])
+            builder.Address(network_data[:address])
+            builder.BroadcastAddress(network_data[:broadcast])
+            builder.GatewayAddress(network_data[:gateway])
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/configure_network_ip.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Vcloud
+    class Compute
+      module Shared
+        private
+
+        def validate_network_ip_data(network_ip_data)
+          valid_opts = [:id, :href, :name, :status, :server]
+          unless valid_opts.all? { |opt| network_ip_data.keys.include?(opt) }
+            raise ArgumentError.new("Required data missing: #{(valid_opts - network_ip_data.keys).map(&:inspect).join(", ")}")
+          end
+        end
+      end
+
+      class Real
+        include Shared
+
+        def configure_network_ip(network_ip_uri, network_ip_data)
+          validate_network_ip_data(network_ip_data)
+
+          request(
+            :body     => generate_configure_network_ip_request(network_ip_data),
+            :expects  => 200,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.ip+xml' },
+            :method   => 'PUT',
+            :uri      => network_ip_uri,
+            :parse    => true
+          )
+        end
+
+        private
+
+        def generate_configure_network_ip_request(network_ip_data)
+          builder = Builder::XmlMarkup.new
+          builder.IpAddress(xmlns) {
+            builder.Id(network_ip_data[:id])
+            builder.Href(network_ip_data[:href])
+            builder.Name(network_ip_data[:name])
+            builder.Status(network_ip_data[:status])
+            builder.Server(network_ip_data[:server])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/configure_node.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Vcloud
+    class Compute
+      module Shared
+        private
+
+        def generate_configure_node_request(node_data)
+          builder = Builder::XmlMarkup.new
+          builder.NodeService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                                  :xmlns => "urn:tmrk:eCloudExtensions-2.0") {
+            builder.Name(node_data[:name])
+            builder.Enabled(node_data[:enabled].to_s)
+            builder.Description(node_data[:description])
+          }
+        end
+
+      end
+
+      class Real
+        include Shared
+
+        def configure_node(node_uri, node_data)
+          validate_node_data(node_data, true)
+
+          request(
+            :body     => generate_configure_node_request(node_data),
+            :expects  => 200,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.nodeService+xml'},
+            :method   => 'PUT',
+            :uri      => node_uri,
+            :parse    => true
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/configure_vapp.rb

@@ -0,0 +1,112 @@
+module Fog
+  module Vcloud
+    class Compute
+      module Shared
+        private
+
+        def validate_vapp_data(vapp_data)
+          valid_opts = [:name, :cpus, :memory, :disks]
+          unless valid_opts.all? { |opt| vapp_data.keys.include?(opt) }
+            raise ArgumentError.new("Required Vapp data missing: #{(valid_opts - vapp_data.keys).map(&:inspect).join(", ")}")
+          end
+        end
+      end
+
+      class Real
+        include Shared
+
+        def generate_configure_vapp_request(vapp_uri, vapp_data)
+          rasd_xmlns = { "xmlns" => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" }
+
+          xml = Nokogiri::XML(request( :uri => vapp_uri).body)
+          xml.root['name'] = vapp_data[:name]
+
+          #cpu
+          xml.at("//xmlns:ResourceType[.='3']/..", rasd_xmlns).at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:cpus]
+
+          #memory
+          xml.at("//xmlns:ResourceType[.='4']/..", rasd_xmlns).at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:memory]
+
+          #disks
+          real_disks = xml.xpath("//xmlns:ResourceType[ .='17']/..", rasd_xmlns)
+          real_disk_numbers = real_disks.map { |disk| disk.at('.//xmlns:AddressOnParent', rasd_xmlns).content }
+          disk_numbers = vapp_data[:disks].map { |vdisk| vdisk[:number].to_s }
+
+          if vapp_data[:disks].length < real_disks.length
+            #Assume we're removing a disk
+            remove_disk_numbers = real_disk_numbers - disk_numbers
+            remove_disk_numbers.each do |number|
+              if result = xml.at("//xmlns:ResourceType[ .='17']/../xmlns:AddressOnParent[.='#{number}']/..", rasd_xmlns)
+                result.remove
+              end
+            end
+          elsif vapp_data[:disks].length > real_disks.length
+            add_disk_numbers = disk_numbers - real_disk_numbers
+
+            add_disk_numbers.each do |number|
+              new_disk = real_disks.first.dup
+              new_disk.at('.//xmlns:AddressOnParent', rasd_xmlns).content = -1
+              new_disk.at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:disks].detect { |disk| disk[:number].to_s == number.to_s }[:size]
+              real_disks.first.parent << new_disk
+            end
+          end
+
+          #puts xml.root.to_s
+          xml.root.to_s
+
+          #builder = Builder::XmlMarkup.new
+          #builder.Vapp(:href => vapp_uri.to_s,
+          #             :type => 'application/vnd.vmware.vcloud.vApp+xml',
+          #             :name => vapp_data[:name],
+          #             :status => 2,
+          #             :size => 0,
+          #             :xmlns => 'http://www.vmware.com/vcloud/v0.8',
+          #             :"xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
+          #             :"xmlns:xsd" => 'http://www.w3.org/2001/XMLSchema') {
+          #  #builder.VirtualHardwareSection(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+          #  builder.Section(:"xsi:type" => "q2:VirtualHardwareSection_Type", :xmlns => "http://schemas.dmtf.org/ovf/envelope/1", :"xmlns:q2" => "http://www.vmware.com/vcloud/v0.8") {
+          #    builder.Info('Virtual Hardware')
+          #    builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+          #    #builder.Item {
+          #      builder.InstanceID(1, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #      builder.ResourceType(3, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #      builder.VirtualQuantity(vapp_data[:cpus], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #    }
+          #    builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+          #    #builder.Item {
+          #      builder.InstanceID(2, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #      builder.ResourceType(4, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #      builder.VirtualQuantity(vapp_data[:memory], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #    }
+          #    vapp_data[:disks].each do |disk_data|
+          #      #builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+          #      builder.Item {
+          #        builder.AddressOnParent(disk_data[:number], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #        builder.HostResource(disk_data[:resource], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #        builder.InstanceID(9, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #        builder.ResourceType(17, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #        builder.VirtualQuantity(disk_data[:size], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+          #      }
+          #    end
+          #
+          #  }
+          #}
+        end
+
+        def configure_vapp(vapp_uri, vapp_data)
+          validate_vapp_data(vapp_data)
+
+          request(
+            :body     => generate_configure_vapp_request(vapp_uri, vapp_data),
+            :expects  => 202,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.vApp+xml' },
+            :method   => 'PUT',
+            :uri      => vapp_uri,
+            :parse    => true
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/configure_vm.rb

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+hardware_hash = {:xmlns_vcloud=>"http://www.vmware.com/vcloud/v1",
+ :vcloud_href=>
+  "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/",
+ :vcloud_type=>"application/vnd.vmware.vcloud.virtualHardwareSection+xml",
+ :"ovf:Info"=>"Virtual hardware requirements",
+ :"ovf:System"=>
+  {:"vssd:ElementName"=>"Virtual Hardware Family",
+   :"vssd:InstanceID"=>"0",
+   :"vssd:VirtualSystemIdentifier"=>"centos",
+   :"vssd:VirtualSystemType"=>"vmx-07"},
+ :"ovf:Item"=>
+  [{:"rasd:Address"=>"00:50:56:01:00:db",
+    :"rasd:AddressOnParent"=>"0",
+    :"rasd:AutomaticAllocation"=>"true",
+    :"rasd:Connection"=>"Gandalf_Dev_OrgNW_to_ExtNW_DirectConnect",
+    :"rasd:Description"=>"PCNet32 ethernet adapter",
+    :"rasd:ElementName"=>"Network adapter 0",
+    :"rasd:InstanceID"=>"1",
+    :"rasd:ResourceSubType"=>"PCNet32",
+    :"rasd:ResourceType"=>"10"},
+   {:"rasd:Address"=>"0",
+    :"rasd:Description"=>"SCSI Controller",
+    :"rasd:ElementName"=>"SCSI Controller 0",
+    :"rasd:InstanceID"=>"2",
+    :"rasd:ResourceSubType"=>"lsilogic",
+    :"rasd:ResourceType"=>"6"},
+   {:"rasd:AddressOnParent"=>"0",
+    :"rasd:Description"=>"Hard disk",
+    :"rasd:ElementName"=>"Hard disk 1",
+    :"rasd:HostResource"=>
+     {:vcloud_capacity=>"8192",
+      :vcloud_busType=>"6",
+      :vcloud_busSubType=>"lsilogic"},
+    :"rasd:InstanceID"=>"2000",
+    :"rasd:Parent"=>"2",
+    :"rasd:ResourceType"=>"17"},
+   {:"rasd:Address"=>"0",
+    :"rasd:Description"=>"IDE Controller",
+    :"rasd:ElementName"=>"IDE Controller 0",
+    :"rasd:InstanceID"=>"3",
+    :"rasd:ResourceType"=>"5"},
+   {:"rasd:AddressOnParent"=>"0",
+    :"rasd:AutomaticAllocation"=>"false",
+    :"rasd:Description"=>"CD/DVD Drive",
+    :"rasd:ElementName"=>"CD/DVD Drive 1",
+    :"rasd:HostResource"=>"",
+    :"rasd:InstanceID"=>"3000",
+    :"rasd:Parent"=>"3",
+    :"rasd:ResourceType"=>"15"},
+   {:"rasd:AddressOnParent"=>"0",
+    :"rasd:AutomaticAllocation"=>"false",
+    :"rasd:Description"=>"Floppy Drive",
+    :"rasd:ElementName"=>"Floppy Drive 1",
+    :"rasd:HostResource"=>"",
+    :"rasd:InstanceID"=>"8000",
+    :"rasd:ResourceType"=>"14"},
+   {:vcloud_href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/cpu",
+    :vcloud_type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :"rasd:AllocationUnits"=>"hertz * 10^6",
+    :"rasd:Description"=>"Number of Virtual CPUs",
+    :"rasd:ElementName"=>"1 virtual CPU(s)",
+    :"rasd:InstanceID"=>"4",
+    :"rasd:Reservation"=>"0",
+    :"rasd:ResourceType"=>"3",
+    :"rasd:VirtualQuantity"=>"1",
+    :"rasd:Weight"=>"0",
+    :Link=>
+     {:rel=>"edit",
+      :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+      :href=>
+       "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/cpu"}},
+   {:vcloud_href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/memory",
+    :vcloud_type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :"rasd:AllocationUnits"=>"byte * 2^20",
+    :"rasd:Description"=>"Memory Size",
+    :"rasd:ElementName"=>"512 MB of memory",
+    :"rasd:InstanceID"=>"5",
+    :"rasd:Reservation"=>"0",
+    :"rasd:ResourceType"=>"4",
+    :"rasd:VirtualQuantity"=>"768",
+    :"rasd:Weight"=>"0",
+    :Link=>
+     {:rel=>"edit",
+      :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+      :href=>
+       "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/memory"}}],
+ :Link=>
+  [{:rel=>"edit",
+    :type=>"application/vnd.vmware.vcloud.virtualHardwareSection+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/"},
+   {:rel=>"down",
+    :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/cpu"},
+   {:rel=>"edit",
+    :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/cpu"},
+   {:rel=>"down",
+    :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/memory"},
+   {:rel=>"edit",
+    :type=>"application/vnd.vmware.vcloud.rasdItem+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/memory"},
+   {:rel=>"down",
+    :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/disks"},
+   {:rel=>"edit",
+    :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/disks"},
+   {:rel=>"down",
+    :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/media"},
+   {:rel=>"down",
+    :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/networkCards"},
+   {:rel=>"edit",
+    :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+    :href=>
+     "https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-624535987/virtualHardwareSection/networkCards"}]}
+
+
+module Fog
+  module Vcloud
+    class Compute
+      module Shared
+        private
+
+        def validate_vm_data(vm_data)
+          valid_opts = [:name, :cpus, :memory, :disks]
+          unless valid_opts.all? { |opt| vm_data.keys.include?(opt) }
+            raise ArgumentError.new("Required vm data missing: #{(valid_opts - vm_data.keys).map(&:inspect).join(", ")}")
+          end
+        end
+      end
+
+      class Real
+        include Shared
+
+        def generate_configure_vm_request(vm_data)
+          xmlns = 'http://schemas.dmtf.org/ovf/envelope/1'
+          xmlns_vcloud = 'http://www.vmware.com/vcloud/v1'
+          xmlns_rasd = 'http://schemas.dmtf.org/wbem/wscim/1/cim‐schema/2/CIM_ResourceAllocationSettingData'
+          xmlns_vssd = 'http://schemas.dmtf.org/wbem/wscim/1/cim‐schema/2/CIM_VirtualSystemSettingData'
+
+          builder = Builder::XmlMarkup.new(:target=>STDOUT, :indent=>2) # TODO - remove params
+          builder.VirtualHardwareSection(
+                                         :"vcloud:href" => vm_data[:"vcloud_href"],
+                                         :"vcloud:type" => vm_data[:"vcloud_type"],
+                                         :name => vm_data[:name],
+                                         :status => 2,
+                                         :size => 0,
+                                         :xmlns => xmlns,
+                                         :"xmlns:vcloud" => xmlns_vcloud,
+                                         :"xmlns:rasd" => xmlns_rasd,
+                                         :"xmlns:vssd" => xmlns_vssd) {
+            #builder.VirtualHardwareSection(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+
+            builder.Info(vm_data[:"ovf:Info"])
+            if system = vm_data[:"ovf:System"]
+              builder.System {
+                builder.ElementName(system[:"vssd:ElementName"], :xmlns => xmlns_vssd) if system[:"vssd:ElementName"]
+                builder.InstanceID(system[:"vssd:InstanceID"], :xmlns => xmlns_vssd) if system[:"vssd:InstanceID"]
+                builder.VirtualSystemIdentifier(system[:"vssd:VirtualSystemIdentifier"], :xmlns => xmlns_vssd) if system[:"vssd:VirtualSystemIdentifier"]
+                builder.VirtualSystemType(system[:"vssd:VirtualSystemType"], :xmlns => xmlns_vssd) if system[:"vssd:VirtualSystemType"]
+              }
+            end
+
+            vm_data[:'ovf:Item'].each do |oi|
+              builder.Item {
+                builder.Address(oi[:'rasd:Address'], :xmlns => xmlns_rasd) if oi[:'rasd:Address']
+                builder.AddressOnParent(oi[:'rasd:AddressOnParent'], :xmlns => xmlns_rasd) if oi[:'rasd:AddressOnParent']
+                builder.AutomaticAllocation(oi[:'rasd:AutomaticAllocation'], :xmlns => xmlns_rasd) if oi[:'rasd:AutomaticAllocation']
+                builder.Connection(oi[:'rasd:Connection'], :xmlns => xmlns_rasd) if oi[:'rasd:Connection']
+                builder.Description(oi[:'rasd:Description'], :xmlns => xmlns_rasd) if oi[:'rasd:Description']
+                builder.ElementName(oi[:'rasd:ElementName'], :xmlns => xmlns_rasd) if oi[:'rasd:ElementName']
+                builder.InstanceID(oi[:'rasd:InstanceID'], :xmlns => xmlns_rasd) if oi[:'rasd:InstanceID']
+                builder.ResourceSubType(oi[:'rasd:ResourceSubType'], :xmlns => xmlns_rasd) if oi[:'rasd:ResourceSubType']
+                builder.ResourceType(oi[:'rasd:ResourceType'], :xmlns => xmlns_rasd) if oi[:'rasd:ResourceType']
+                if hr = oi[:'rasd:HostResource']
+                  attrs = {}
+                  attrs[]
+                end
+              }
+            end
+
+
+
+             # builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+             # #builder.Item {
+             #   builder.InstanceID(1, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #   builder.ResourceType(3, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #   builder.VirtualQuantity(vm_data[:cpus], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             # }
+             # builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+             # #builder.Item {
+             #   builder.InstanceID(2, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #   builder.ResourceType(4, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #   builder.VirtualQuantity(vm_data[:memory], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             # }
+             # vm_data[:disks].each do |disk_data|
+             #   #builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+             #   builder.Item {
+             #     builder.AddressOnParent(disk_data[:number], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #     builder.HostResource(disk_data[:resource], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #     builder.InstanceID(9, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #     builder.ResourceType(17, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #     builder.VirtualQuantity(disk_data[:size], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+             #   }
+             # end
+
+           }
+        end
+
+        def configure_vm(vm_uri, vm_data)
+          validate_vm_data(vm_data)
+
+          request(
+            :body     => generate_configure_vm_request(vm_uri, vm_data),
+            :expects  => 202,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.vm+xml' },
+            :method   => 'PUT',
+            :uri      => vm_uri,
+            :parse    => true
+          )
+        end
+
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'builder'
+  i = Fog::Vcloud::Compute::Real.new
+  puts i.generate_configure_vm_request(hardware_hash)
+end