fog 1.0.0 → 1.5.0

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

@@ -9,8 +9,14 @@ module Fog
 
         model Fog::Compute::Vsphere::Server
 
-        def all
-          response = connection.list_virtual_machines
+        # 'path' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
+        # than simply listing everything.
+        def all(filters = {})
+          # REVISIT: I'm not sure if this is the best way to implement search
+          # filters on a collection but it does work.  I need to study the AWS
+          # code more to make sure this matches up.
+          filters['folder'] ||= attributes['folder']
+          response = connection.list_virtual_machines(filters)
           load(response['virtual_machines'])
         end
 

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

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def datacenters
+          @datacenters ||= datacenters_reload
+          # Hide the values which are the RbVmomi instances
+          @datacenters.keys
+        end
+
+        private
+
+        def datacenters_reload
+          @rootfolder  ||= @connection.rootFolder
+          inventory = @rootfolder.inventory(:Datacenter => [ 'name' ])[@rootfolder]
+          # Convert the inventory into a Hash of the form: We remove the
+          # property selectors.  { "<dc_name>" => #<RbVmomi::VIM::Datacenter> }
+          # The Datacenter instance itself is at index 0 and the properties we
+          # collected are at index 1.
+          inventory.inject({}) do |memo, (name,dc_ary)|
+            memo[name] = dc_ary[0]
+            memo
+          end
+        end
+      end
+
+      class Mock
+        def datacenters
+          [ "Solutions", "Solutions2", "Solutions3" ]
+        end
+      end
+    end
+  end
+end

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 }
@@ -34,6 +78,7 @@ module Fog
           { 'virtual_machines' => virtual_machines }
         end
 
+
         # NOTE: This is a private instance method required by the vm_clone
         # request.  It's very hard to get the Managed Object Reference
         # of a Template because we can't search for it by instance_uuid
@@ -45,119 +90,147 @@ module Fog
           datacenters = @connection.rootFolder.children.find_all do |child|
             child.kind_of? RbVmomi::VIM::Datacenter
           end
-          # Next, look in the "vmFolder" of each data center:
+          # Next, search the "vmFolder" inventory of each data center:
           datacenters.each do |dc|
-            dc.vmFolder.children.each do |vm|
-              virtual_machines << vm
+            inventory = dc.vmFolder.inventory( 'VirtualMachine' => :all )
+            virtual_machines << find_all_in_inventory(inventory, :type => RbVmomi::VIM::VirtualMachine, :property => 'name' )
+          end
+
+          virtual_machines.flatten
+        end
+
+        def find_all_in_inventory(inventory, properties = { :type => RbVmomi::VIM::VirtualMachine, :property => nil } )
+          results = Array.new
+
+          inventory.each do |k,v|
+
+            # If we have a VMware folder we need to traverse the directory
+            # to ensure we pick VMs inside folders. So we do a bit of recursion
+            # here.
+            results << find_all_in_inventory(v) if k.is_a? RbVmomi::VIM::Folder
+
+            if v[0].is_a? properties[:type]
+              if properties[:property].nil?
+                results << v[0]
+              else
+                results << v[1][properties[:property]]
+              end
             end
           end
-          virtual_machines
+          results.flatten
         end
 
+        def get_folder_path(folder, root = nil)
+          if ( not folder.methods.include?('parent') ) or ( folder == root )
+            return
+          end
+          "#{get_folder_path(folder.parent)}/#{folder.name}"
+        end
       end
 
       class Mock
 
+        def get_folder_path(folder, root = nil)
+          nil
+        end
+
         def list_virtual_machines(options = {})
           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.datacenters.join(",")} are accessible."
           end
           options
         end
@@ -25,52 +34,128 @@ 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 to use for the clone
+          # (REVISIT: We need to support cloning into a specific RP)
+
+          if ( vm_mob_ref.resourcePool == nil )
+            # If the template is really a template then there is no associated resource pool,
+            # so we need to find one using the template's parent host or cluster
+            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
+          else
+            # If the vm given did return a valid resource pool, default to using it for the clone.
+            # Even if specific pools aren't implemented in this environment, we will still get back
+            # at least the cluster or host we can pass on to the clone task
+            resource_pool = vm_mob_ref.resourcePool
+          end
+          
+          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
 
@@ -81,13 +166,13 @@ module Fog
         def vm_clone(options = {})
           # 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" }
           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_config_vnc.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_config_vnc(options = { })
+          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 => {
+            :extraConfig => [
+              { :key => 'RemoteDisplay.vnc.enabled',  :value => options[:enabled] ? 'true' : 'false' },
+              { :key => 'RemoteDisplay.vnc.password', :value => options[:password].to_s },
+              { :key => 'RemoteDisplay.vnc.port',     :value => options[:port].to_s || '5910' }
+            ]
+          })
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+
+        # return a hash of VNC attributes required to view the console
+        def vm_get_vnc uuid
+
+          search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
+          vm = @connection.searchIndex.FindAllByUuid(search_filter).first
+          Hash[vm.config.extraConfig.map do |config|
+            if config.key =~ /^RemoteDisplay\.vnc\.(\w+)$/
+              [$1.to_sym, config.value]
+            end
+          end.compact]
+        end
+
+      end
+
+      class Mock
+        def vm_config_vnc(options = { })
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+
+        def vm_get_vnc uuid
+          {:password => 'secret', :port => '5900', :enabled => 'true'}
+        end
+      end
+    end
+  end
+end