fog 1.1.1 → 1.2.0

data/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -1,13 +1,15 @@
 module Fog
   module Compute
     class Vsphere
-
       class Real
-
         def list_virtual_machines(options = {})
-          # First, determine if there's a search filter
+          # Listing all VM's can be quite slow and expensive.  Try and optimize
+          # based on the available options we have.  These conditions are in
+          # ascending order of  time to complete for large deployments.
           if options['instance_uuid'] then
             list_all_virtual_machines_by_instance_uuid(options)
+          elsif options['folder'] then
+            list_all_virtual_machines_in_folder(options)
           else
             list_all_virtual_machines
           end
@@ -15,6 +17,48 @@ module Fog
 
         private
 
+        def list_all_virtual_machines_in_folder(options = {})
+          # Tap gets rid of the leading empty string and "Datacenters" element
+          # and returns the array.
+          path_elements = options['folder'].split('/').tap { |ary| ary.shift 2 }
+          # The DC name itself.
+          dc_name = path_elements.shift
+          # If the first path element contains "vm" this denotes the vmFolder
+          # and needs to be shifted out since each DC contains only one
+          # vmFolder
+          path_elements.shift if path_elements[0] == 'vm'
+          # Make sure @datacenters is populated (the keys are DataCenter instances)
+          self.datacenters.include? dc_name or raise ArgumentError, "Could not find a Datacenter named #{dc_name}"
+          # Get the datacenter managed object
+          dc = @datacenters[dc_name]
+
+          # Get the VM Folder (Group) efficiently
+          vm_folder = dc.vmFolder
+
+          # Walk the tree resetting the folder pointer as we go
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
+          end
+
+          # This should be efficient since we're not obtaining properties
+          virtual_machines = folder.children.inject([]) do |ary, child|
+            if child.is_a? RbVmomi::VIM::VirtualMachine then
+              ary << convert_vm_mob_ref_to_attr_hash(child)
+            end
+            ary
+          end
+
+          # Return the managed objects themselves as an array.  These may be converted
+          # to an attribute has using convert_vm_mob_ref_to_attr_hash
+          { 'virtual_machines' => virtual_machines }
+        end
+
         def list_all_virtual_machines_by_instance_uuid(options = {})
           uuid = options['instance_uuid']
           search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
@@ -94,102 +138,99 @@ module Fog
           case options['instance_uuid']
           when nil
             rval = YAML.load <<-'ENDvmLISTING'
-              --- 
-              virtual_machines: 
-              - name: centos56gm
-                hypervisor: gunab.puppetlabs.lan
-                tools_version: guestToolsCurrent
-                ipaddress: 
-                mo_ref: vm-698
-                power_state: poweredOff
-                uuid: 42322347-d791-cd34-80b9-e25fe28ad37c
-                is_a_template: true
-                id: 50323f93-6835-1178-8b8f-9e2109890e1a
-                tools_state: toolsNotRunning
-                connection_state: connected
-                instance_uuid: 50323f93-6835-1178-8b8f-9e2109890e1a
-                hostname: 
-                mac_addresses: 
-                  Network adapter 1: 00:50:56:b2:00:a1
-                operatingsystem: 
-              - name: centos56gm2
-                hypervisor: gunab.puppetlabs.lan
-                tools_version: guestToolsCurrent
-                ipaddress: 
-                mo_ref: vm-640
-                power_state: poweredOff
-                uuid: 564ddcbe-853a-d29a-b329-a0a3693a004d
-                is_a_template: true
-                id: 5257dee8-050c-cbcd-ae25-db0e582ab530
-                tools_state: toolsNotRunning
-                connection_state: connected
-                instance_uuid: 5257dee8-050c-cbcd-ae25-db0e582ab530
-                hostname: 
-                mac_addresses: 
-                  Network adapter 1: 00:0c:29:3a:00:4d
-                operatingsystem: 
-              - name: dashboard_gm
-                hypervisor: gunab.puppetlabs.lan
-                tools_version: guestToolsCurrent
-                ipaddress: 192.168.100.184
-                mo_ref: vm-669
-                power_state: poweredOn
-                uuid: 564d3f91-3452-a509-a678-1246f7897979
-                is_a_template: false
-                id: 5032739c-c871-c0d2-034f-9700a0b5383e
-                tools_state: toolsOk
-                connection_state: connected
-                instance_uuid: 5032739c-c871-c0d2-034f-9700a0b5383e
-                hostname: compliance.puppetlabs.vm
-                mac_addresses: 
-                  Network adapter 1: 00:50:56:b2:00:96
-                operatingsystem: Red Hat Enterprise Linux 6 (64-bit)
-              - name: jefftest
-                hypervisor: gunab.puppetlabs.lan
-                tools_version: guestToolsCurrent
-                ipaddress: 192.168.100.187
-                mo_ref: vm-715
-                power_state: poweredOn
-                uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-                is_a_template: false
-                id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-                tools_state: toolsOk
-                connection_state: connected
-                instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-                hostname: centos56gm.localdomain
-                mac_addresses: 
-                  Network adapter 1: 00:50:56:b2:00:af
-                operatingsystem: CentOS 4/5 (32-bit)
-            ENDvmLISTING
+---
+virtual_machines:
+- name: centos56gm
+  hypervisor: gunab.puppetlabs.lan
+  tools_version: guestToolsCurrent
+  ipaddress:
+  mo_ref: vm-698
+  power_state: poweredOff
+  uuid: 42322347-d791-cd34-80b9-e25fe28ad37c
+  is_a_template: true
+  id: 50323f93-6835-1178-8b8f-9e2109890e1a
+  tools_state: toolsNotRunning
+  connection_state: connected
+  instance_uuid: 50323f93-6835-1178-8b8f-9e2109890e1a
+  hostname:
+  mac_addresses:
+    Network adapter 1: 00:50:56:b2:00:a1
+  operatingsystem:
+- name: centos56gm2
+  hypervisor: gunab.puppetlabs.lan
+  tools_version: guestToolsCurrent
+  ipaddress:
+  mo_ref: vm-640
+  power_state: poweredOff
+  uuid: 564ddcbe-853a-d29a-b329-a0a3693a004d
+  is_a_template: true
+  id: 5257dee8-050c-cbcd-ae25-db0e582ab530
+  tools_state: toolsNotRunning
+  connection_state: connected
+  instance_uuid: 5257dee8-050c-cbcd-ae25-db0e582ab530
+  hostname:
+  mac_addresses:
+    Network adapter 1: 00:0c:29:3a:00:4d
+  operatingsystem:
+- name: dashboard_gm
+  hypervisor: gunab.puppetlabs.lan
+  tools_version: guestToolsCurrent
+  ipaddress: 192.168.100.184
+  mo_ref: vm-669
+  power_state: poweredOn
+  uuid: 564d3f91-3452-a509-a678-1246f7897979
+  is_a_template: false
+  id: 5032739c-c871-c0d2-034f-9700a0b5383e
+  tools_state: toolsOk
+  connection_state: connected
+  instance_uuid: 5032739c-c871-c0d2-034f-9700a0b5383e
+  hostname: compliance.puppetlabs.vm
+  mac_addresses:
+    Network adapter 1: 00:50:56:b2:00:96
+  operatingsystem: Red Hat Enterprise Linux 6 (64-bit)
+- name: jefftest
+  hypervisor: gunab.puppetlabs.lan
+  tools_version: guestToolsCurrent
+  ipaddress: 192.168.100.187
+  mo_ref: vm-715
+  power_state: poweredOn
+  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
+  is_a_template: false
+  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
+  tools_state: toolsOk
+  connection_state: connected
+  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
+  hostname: centos56gm.localdomain
+  mac_addresses:
+    Network adapter 1: 00:50:56:b2:00:af
+  operatingsystem: CentOS 4/5 (32-bit)
+ENDvmLISTING
           when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
             YAML.load <<-'5032c8a5-9c5e-ba7a-3804-832a03e16381'
-              --- 
-              virtual_machines: 
-              - name: jefftest
-                hypervisor: gunab.puppetlabs.lan
-                tools_version: guestToolsCurrent
-                ipaddress: 192.168.100.187
-                mo_ref: vm-715
-                power_state: poweredOn
-                uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-                is_a_template: false
-                id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-                tools_state: toolsOk
-                connection_state: connected
-                instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-                hostname: centos56gm.localdomain
-                mac_addresses: 
-                  Network adapter 1: 00:50:56:b2:00:af
-                operatingsystem: CentOS 4/5 (32-bit)
+---
+virtual_machines:
+- name: jefftest
+  hypervisor: gunab.puppetlabs.lan
+  tools_version: guestToolsCurrent
+  ipaddress: 192.168.100.187
+  mo_ref: vm-715
+  power_state: poweredOn
+  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
+  is_a_template: false
+  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
+  tools_state: toolsOk
+  connection_state: connected
+  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
+  hostname: centos56gm.localdomain
+  mac_addresses:
+    Network adapter 1: 00:50:56:b2:00:af
+  operatingsystem: CentOS 4/5 (32-bit)
             5032c8a5-9c5e-ba7a-3804-832a03e16381
           when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
             { 'virtual_machines' => [] }
           end
         end
-
       end
-
     end
   end
 end
-

data/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -5,15 +5,24 @@ module Fog
       module Shared
         private
         def vm_clone_check_options(options)
-          options = { 'force' => false }.merge(options)
-          required_options = %w{ instance_uuid name }
+          default_options = {
+            'force'        => false,
+            'linked_clone' => false,
+          }
+          options = default_options.merge(options)
+          required_options = %w{ path name }
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # First, figure out if there's already a VM of the same name.
-          all_virtual_machines = list_virtual_machines['virtual_machines']
-          if not options['force'] and all_virtual_machines.detect { |vm| vm['name'] == options['name'] } then
-            raise Fog::Vsphere::Errors::ServiceError, "A VM already exists with name #{options['name']}"
+          # The tap removes the leading empty string
+          path_elements = options['path'].split('/').tap { |o| o.shift }
+          first_folder = path_elements.shift
+          if first_folder != 'Datacenters' then
+            raise ArgumentError, "vm_clone path option must start with /Datacenters.  Got: #{options['path']}"
+          end
+          dc_name = path_elements.shift
+          if not self.datacenters.include? dc_name then
+            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.dacenters.join(",")} are accessible."
           end
           options
         end
@@ -25,52 +34,117 @@ module Fog
           # Option handling
           options = vm_clone_check_options(options)
 
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
+          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
 
-          # REVISIT: This will have horrible performance for large sites.
-          # Find the Managed Object reference of the template VM (Wish I could do this with the API)
-          vm_mob_ref = list_all_virtual_machine_mobs.find(notfound) do |vm|
-            convert_vm_mob_ref_to_attr_hash(vm)['instance_uuid'] == options['instance_uuid']
+          # Find the template in the folder.  This is more efficient than
+          # searching ALL VM's looking for the template.
+          # Tap gets rid of the leading empty string and "Datacenters" element
+          # and returns the array.
+          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
+          # The DC name itself.
+          template_dc = path_elements.shift
+          # If the first path element contains "vm" this denotes the vmFolder
+          # and needs to be shifted out
+          path_elements.shift if path_elements[0] == 'vm'
+          # The template name.  The remaining elements are the folders in the
+          # datacenter.
+          template_name = path_elements.pop
+          # Make sure @datacenters is populated.  We need the instances from the Hash keys.
+          self.datacenters
+          # Get the datacenter managed object from the hash
+          dc = @datacenters[template_dc]
+          # Get the VM Folder (Group) efficiently
+          vm_folder = dc.vmFolder
+          # Walk the tree resetting the folder pointer as we go
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
           end
 
-          # We need to locate the datacenter object to find the
-          # default resource pool.
-          container = vm_mob_ref.parent
-          until container.kind_of? RbVmomi::VIM::Datacenter
-            container = container.parent
+          # Now find the template itself using the efficient find method
+          vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
+
+          # Now find _a_ resource pool of the template's host (REVISIT: We need
+          # to support cloning into a specific RP)
+          esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
+          # The parent of the ESX host itself is a ComputeResource which has a resourcePool
+          resource_pool = esx_host.parent.resourcePool
+          relocation_spec=nil
+          if ( options['linked_clone'] )
+            # cribbed heavily from the rbvmomi clone_vm.rb
+            # this chunk of code reconfigures the disk of the clone source to be read only,
+            # and then creates a delta disk on top of that, this is required by the API in order to create
+            # linked clondes
+            disks = vm_mob_ref.config.hardware.device.select do |vm_device|
+              vm_device.class == RbVmomi::VIM::VirtualDisk
+            end
+            disks.select{|vm_device| vm_device.backing.parent == nil}.each do |disk|
+              disk_spec = {
+                :deviceChange => [
+                  {
+                    :operation => :remove,
+                    :device => disk
+                  },
+                  {
+                    :operation => :add,
+                    :fileOperation => :create,
+                    :device => disk.dup.tap{|disk_backing|
+                      disk_backing.backing = disk_backing.backing.dup;
+                      disk_backing.backing.fileName = "[#{disk.backing.datastore.name}]";
+                      disk_backing.backing.parent = disk.backing
+                    }
+                  },
+                ]
+              }
+              vm_mob_ref.ReconfigVM_Task(:spec => disk_spec).wait_for_completion
+            end
+            # Next, create a Relocation Spec instance
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+                                                                      :diskMoveType => :moveChildMostDiskBacking)
+          else
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+                                                                      :transform => options['transform'] || 'sparse')
           end
-          dc = container
-          # With the Datacenter Object we can obtain the resource pool
-          resource_pool = dc.hostFolder.children.first.resourcePool
-          # Next, create a Relocation Spec instance
-          relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
-                                                                    :transform => options['transform'] || 'sparse')
           # And the clone specification
           clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
                                                             :powerOn  => options['power_on'] || true,
                                                             :template => false)
           task = vm_mob_ref.CloneVM_Task(:folder => vm_mob_ref.parent, :name => options['name'], :spec => clone_spec)
-          # REVISIT: The task object contains a reference to the template but does
-          # not appear to contain a reference to the newly created VM.
-          # This is a really naive way to find the managed object reference
-          # of the newly created VM.
-          tries = 0
-          new_vm = begin
-            list_virtual_machines['virtual_machines'].detect(lambda { raise Fog::Vsphere::Errors::NotFound }) do |vm|
-              vm['name'] == options['name']
+          # Waiting for the VM to complete allows us to get the VirtulMachine
+          # object of the new machine when it's done.  It is HIGHLY recommended
+          # to set 'wait' => true if your app wants to wait.  Otherwise, you're
+          # going to have to reload the server model over and over which
+          # generates a lot of time consuming API calls to vmware.
+          if options['wait'] then
+            # REVISIT: It would be awesome to call a block passed to this
+            # request to notify the application how far along in the process we
+            # are.  I'm thinking of updating a progress bar, etc...
+            new_vm = task.wait_for_completion
+          else
+            tries = 0
+            new_vm = begin
+              # Try and find the new VM (folder.find is quite efficient)
+              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+            rescue Fog::Vsphere::Errors::NotFound
+              tries += 1
+              if tries <= 10 then
+                sleep 15
+                retry
+              end
+              nil
             end
-          rescue Fog::Vsphere::Errors::NotFound
-            tries += 1
-            if tries <= 10 then
-              sleep 1
-              retry
-            end
-            nil
           end
+
           # Return hash
           {
-            'vm_ref'   => new_vm ? new_vm['mo_ref'] : nil,
-            'task_ref' => task._ref
+            'vm_ref'        => new_vm ? new_vm._ref : nil,
+            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'task_ref'      => task._ref
           }
         end
 
@@ -83,11 +157,11 @@ module Fog
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
           vm_mob_ref = list_virtual_machines['virtual_machines'].find(notfound) do |vm|
-            vm['instance_uuid'] == options['instance_uuid']
+            vm['name'] == options['path'].split("/")[-1]
           end
           {
             'vm_ref'   => 'vm-123',
-            'task_ref' => 'task-1234'
+            'task_ref' => 'task-1234',
           }
         end
 

data/lib/fog/vsphere/requests/compute/vm_create.rb

@@ -0,0 +1,97 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      module Shared
+        private
+        def vm_create_check_options(options)
+          options = { 'force' => false }.merge(options)
+          required_options = %w{ path name cluster }
+          required_options.each do |param|
+            raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
+          end
+          # The tap removes the leading empty string
+          path_elements = options['path'].split('/').tap { |o| o.shift }
+          first_folder = path_elements.shift
+          if first_folder != 'Datacenters' then
+            raise ArgumentError, "vm_create path option must start with /Datacenters.  Got: #{options['path']}"
+          end
+          dc_name = path_elements.shift
+          if not self.datacenters.include? dc_name then
+            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.datacenters.join(",")} are accessible."
+          end
+          options
+        end
+      end
+
+      class Real
+        include Shared
+        def vm_create(options = {})
+          # Option handling
+          options = vm_create_check_options(options)
+          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
+          dc_name = path_elements.shift
+          vm_cfg = {
+            :name                => options['name'],
+            :guestId             => options['guest_id'] ? options['guest_id'] : 'otherGuest',
+            :files               => { :vmPathName => "[#{options['datastore']}]" },
+            :numCPUs             => options['num_cpus'] ? options['num_cpus'] : 1 ,
+            :memoryMB            => options['memory'] ? options['memory'] : 512,
+            :memoryHotAddEnabled => options['memory_hot_add_enabled'] ? options['memory_hot_add_enabled'] : 0,
+            :cpuHotAddEnabled    => options['cpu_hot_add_enabled'] ? options['cpu_hot_add_enabled'] : 0,
+            :deviceChange        => options['device_array'].class == Array ? options['device_array'] : nil,
+            :extraConfig         => options['extra_config'].class == Array ? options['extra_config'] : nil,
+          }
+          self.datacenters
+          dc = @datacenters[dc_name]
+          vm_folder = dc.vmFolder
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
+          end
+          clusters = dc.hostFolder.children
+          build_cluster=''
+          clusters.each { |my_cluster|
+            if "#{my_cluster.name}" == "#{options['cluster']}"
+              build_cluster=my_cluster
+            end
+          }
+          resource_pool = build_cluster.resourcePool
+          task=folder.CreateVM_Task(:config => vm_cfg, :pool => resource_pool)
+          if options['wait'] then
+            new_vm = task.wait_for_completion
+          else
+            tries = 0
+            new_vm = begin
+              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+            rescue Fog::Vsphere::Errors::NotFound
+              tries += 1
+              if tries <= 10 then
+                sleep 15
+                retry
+              end
+                nil
+            end
+          end
+          {
+            'vm_ref'        => new_vm ? new_vm._ref : nil,
+            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'task_ref'      => task._ref
+          }
+        end
+      end
+      class Mock
+        include Shared
+        def vm_create(options = {})
+          # Option handling
+          options = vm_create_check_options(options)
+          {
+            'vm_ref'   => 'vm-123',
+            'task_ref' => 'task-1234'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_migrate.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+
+        def vm_migrate(options = {})
+          #priority is the only required option, and it has a sane default option.
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+
+          # Find the VM Object
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          unless vm_mob_ref.kind_of? RbVmomi::VIM::VirtualMachine
+            raise Fog::Vsphere::Errors::NotFound,
+              "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
+          end
+          task = vm_mob_ref.MigrateVM_Task(:pool => options['pool'], :host => options['host'], :priority => "#{priority}", :state => options['state'] )
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+
+      end
+
+      class Mock
+
+        def vm_migrate(options = {})
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reconfig_cpus.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.has_key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+
+      class Mock
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.has_key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reconfig_hardware.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.has_key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+          task = vm_mob_ref.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
+          task.wait_for_completion
+           { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.has_key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end