fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_customfields()
+          @connection.serviceContent.customFieldsManager.field.map do |customfield|
+            {
+              :key   => customfield.key.to_i,
+              :name  => customfield.name,
+              :type  => customfield.type
+            }
+          end
+        end
+
+      end
+      class Mock
+        def list_vm_customfields()
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,7 @@ module Fog
 
         protected
 
+        # RbVmomi::VIM::Datacenter Array
         def raw_datacenters
           @raw_datacenters ||= @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
         end

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

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_templates(options = { })
+          options[:folder] ||= options['folder']
+          if options[:folder] then
+            list_all_templates_in_folder(options[:folder], options[:datacenter])
+          else
+            list_all_templates(options)
+          end
+        end
+
+        private
+
+        def list_all_templates_in_folder(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
+
+          vms = folder.children.grep(RbVmomi::VIM::VirtualMachine)
+          # remove all virtual machines that are not template
+          vms.delete_if { |v| v.config.nil? or not v.config.template }
+
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
+        end
+
+        def list_all_templates(options = {})
+          datacenters = find_datacenters(options[:datacenter])
+
+          vms = datacenters.map do |dc|
+            @connection.serviceContent.viewManager.CreateContainerView({
+              :container  => dc.vmFolder,
+              :type       =>  ["VirtualMachine"],
+              :recursive  => true
+            }).view
+          end.flatten
+          # remove all virtual machines that are not templates
+          vms.delete_if { |v| v.config.nil? or not v.config.template }
+
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
+        end
+
+      end
+      class Mock
+        def list_templates(filters = { })
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Fog
 
           options[:folder] ||= options['folder']
           if options['instance_uuid'] then
-            [service.get_virtual_machine(options['instance_uuid'])]
+            [get_virtual_machine(options['instance_uuid'])]
           elsif options[:folder] && options[:datacenter] then
             list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
           else
@@ -22,19 +22,28 @@ module Fog
         def list_all_virtual_machines_in_folder(path, datacenter_name)
           folder = get_raw_vmfolder(path, datacenter_name)
 
-          folder.children.grep(RbVmomi::VIM::VirtualMachine).map(&method(:convert_vm_mob_ref_to_attr_hash))
+          vms = folder.children.grep(RbVmomi::VIM::VirtualMachine)
+          # remove all template based virtual machines
+          vms.delete_if { |v| v.config.nil? or v.config.template }
+          vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
         end
 
         def list_all_virtual_machines(options = { })
           datacenters = find_datacenters(options[:datacenter])
-          # TODO: go though nested folders
-          vms         = datacenters.map { |dc| dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine) }.flatten
-          # remove all template based virtual machines
-          vms.delete_if { |v| v.config.template }
 
-          vms.map do |vm_mob|
-            convert_vm_mob_ref_to_attr_hash(vm_mob)
-          end
+          vms = datacenters.map do |dc|
+            @connection.serviceContent.viewManager.CreateContainerView({
+              :container  => dc.vmFolder,
+              :type       =>  ["VirtualMachine"],
+              :recursive  => true
+            }).view
+          end.flatten
+
+          vms = convert_vm_view_to_attr_hash(vms)
+
+          # remove all template based virtual machines
+          vms.delete_if { |v| v['template'] }
+          vms
         end
 
         def get_folder_path(folder, root = nil)
@@ -52,119 +61,13 @@ module Fog
         end
 
         def list_virtual_machines(options = { })
-          case options['instance_uuid']
-            when nil
-
-              [
-                { :resource_pool    => "Resources",
-                  :memory_mb        => 2196,
-                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:28" },
-                  :power_state      => "poweredOn",
-                  :cpus             => 1,
-                  :hostname         => "dhcp75-197.virt.bos.redhat.com",
-                  :mo_ref           => "vm-562",
-                  :connection_state => "connected",
-                  :overall_status   => "green",
-                  :datacenter       => "Solutions",
-                  :volumes          =>
-                    [{
-                       :id        => "6000C29c-a47d-4cd9-5249-c371de775f06",
-                       :datastore => "Storage1",
-                       :mode      => "persistent",
-                       :size      => 8388608,
-                       :thin      => true,
-                       :name      => "Hard disk 1",
-                       :filename  => "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
-                       :size_gb   => 8
-                     }],
-                  :interfaces       =>
-                    [{ :mac     => "00:50:56:a9:00:28",
-                       :network => "VM Network",
-                       :name    => "Network adapter 1",
-                       :status  => "ok",
-                       :summary => "VM Network",
-                     }],
-                  :hypervisor       => "gunab.puppetlabs.lan",
-                  :guest_id         => "rhel6_64Guest",
-                  :tools_state      => "toolsOk",
-                  :cluster          => "Solutionscluster",
-                  :name             => "rhel64",
-                  :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
-                  :uuid             => "4229f0e9-bfdc-d9a7-7bac-12070772e6dc",
-                  :path             => "/Datacenters/Solutions/vm",
-                  :id               => "5029c440-85ee-c2a1-e9dd-b63e39364603",
-                  :tools_version    => "guestToolsUnmanaged",
-                  :ipaddress        => "192.168.100.184",
-                },
-                { :resource_pool    => "Resources",
-                  :memory_mb        => 512,
-                  :power_state      => "poweredOn",
-                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:00" },
-                  :hostname         => nil,
-                  :cpus             => 1,
-                  :connection_state => "connected",
-                  :mo_ref           => "vm-621",
-                  :overall_status   => "green",
-                  :datacenter       => "Solutions",
-                  :volumes          =>
-                    [{ :thin      => false,
-                       :size_gb   => 10,
-                       :datastore => "datastore1",
-                       :filename  => "[datastore1] i-1342439683/i-1342439683.vmdk",
-                       :size      => 10485762,
-                       :name      => "Hard disk 1",
-                       :mode      => "persistent",
-                       :id        => "6000C29b-f364-d073-8316-8e98ac0a0eae" }],
-                  :interfaces       =>
-                    [{  :summary => "VM Network",
-                       :mac     => "00:50:56:a9:00:00",
-                       :status  => "ok",
-                       :network => "VM Network",
-                       :name    => "Network adapter 1" }],
-                  :instance_uuid    => "502916a3-b42e-17c7-43ce-b3206e9524dc",
-                  :hypervisor       => "gunab.puppetlabs.lan",
-                  :guest_id         => nil,
-                  :cluster          => "Solutionscluster",
-                  :tools_state      => "toolsNotInstalled",
-                  :uuid             => "4229e0de-30cb-ceb2-21f9-4d8d8beabb52",
-                  :name             => "i-1342439683",
-                  :operatingsystem  => nil,
-                  :path             => "/",
-                  :tools_version    => "guestToolsNotInstalled",
-                  :id               => "502916a3-b42e-17c7-43ce-b3206e9524dc",
-                  :ipaddress        => nil }
-
-
-              ]
-            when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
-              [{ :resource_pool    => "Resources",
-                 :memory_mb        => 2196,
-                 :power_state      => "poweredOn",
-                 :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
-                 :hostname         => "centos56gm.localdomain",
-                 :cpus             => 1,
-                 :connection_state => "connected",
-                 :mo_ref           => "vm-715",
-                 :overall_status   => "green",
-                 :datacenter       => "Solutions",
-                 :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
-                 :hypervisor       => "gunab.puppetlabs.lan",
-                 :guest_id         => "rhel6_64Guest",
-                 :cluster          => "Solutionscluster",
-                 :tools_state      => "toolsOk",
-                 :name             => "jefftest",
-                 :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
-                 :path             => "/",
-                 :tools_version    => "guestToolsUnmanaged",
-                 :ipaddress        => "192.168.100.187",
-                 :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
-                 :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
-
-               }
-
-              ]
-            when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
-              []
+          if options['instance_uuid'].nil? and options['mo_ref'].nil?
+            self.data[:servers].values
+          elsif !options['instance_uuid'].nil?
+            server = self.data[:servers][options['instance_uuid']]
+            server.nil? ? [] : [server]
+          else
+            self.data[:servers].values.select{|vm| vm['mo_ref'] == options['mo_ref']}
           end
         end
       end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_vm_customvalues(vm_id)
+          get_vm_ref(vm_id).summary.customValue.map do |customvalue|
+            {
+              :key    => customvalue.key.to_i,
+              :value  => customvalue.value,
+            }
+          end
+
+        end
+
+      end
+      class Mock
+        def list_vm_customfields(vm_id)
+        end
+      end
+    end
+  end
+end

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

@@ -33,14 +33,27 @@ module Fog
             {
               :name    => nic.deviceInfo.label,
               :mac     => nic.macAddress,
-              :network => nic.backing.network.name,
+              :network => nic.backing.respond_to?("network") ? nic.backing.network.name : nic.backing.port.portgroupKey,
               :status  => nic.connectable.status,
               :summary => nic.deviceInfo.summary,
               :type    => nic.class,
+              :key     => nic.key,
             }
           end
 
         end
+        
+        def get_vm_interface(vm_id, options={})
+          raise ArgumentError, "instance id is a required parameter" unless vm_id
+          if options.is_a? Fog::Compute::Vsphere::Interface
+            options
+          else
+            raise ArgumentError, "Either key or name is a required parameter. options: #{options}" unless options.has_key? :key or options.has_key? :mac or options.has_key? :name
+            list_vm_interfaces(vm_id).find do | nic |
+              (options.has_key? :key and nic[:key]==options[:key].to_i) or (options.has_key? :mac and nic[:mac]==options[:mac]) or (options.has_key? :name and nic[:name]==options[:name])
+            end
+          end
+        end
 
       end
       class Mock

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

@@ -0,0 +1,58 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+
+        def add_vm_interface(vmid, options = {})
+          raise ArgumentError, "instance id is a required parameter" unless vmid
+
+          interface=get_interface_from_options(vmid, options)
+          vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface)]})
+        end
+
+        def destroy_vm_interface(vmid, options = {})
+          raise ArgumentError, "instance id is a required parameter" unless vmid
+
+          interface=get_vm_interface(vmid, options)
+          vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, interface.key, :remove)]})
+        end
+        
+        def update_vm_interface(vmid, options = {})
+          raise ArgumentError, "instance id is a required parameter" unless vmid
+
+          interface=get_vm_interface(vmid, options)
+          vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, interface.key, :edit)]})          
+        end
+
+        private
+        def get_interface_from_options(vmid, options)
+          if options and options[:interface]
+            options[:interface]
+          elsif options[:key] and options[:key]>0
+            oldattributes=get_vm_interface(vmid, options)
+            Fog::Compute::Vsphere::Interface.new oldattributes.merge options
+          elsif options[:type] and options[:network]
+            Fog::Compute::Vsphere::Interface.new options
+          else
+            raise ArgumentError, "interface is a required parameter or pass options with type and network"
+          end
+        end
+
+      end
+
+      class Mock
+        def add_vm_interface(vmid, options = {})
+          raise ArgumentError, "instance id is a required parameter" unless vmid
+          raise ArgumentError, "interface is a required parameter" unless options and options[:interface]
+          true
+        end
+
+        def destroy_vm_interface(vmid, options = {})
+          raise ArgumentError, "instance id is a required parameter" unless vmid
+          raise ArgumentError, "interface is a required parameter" unless options and options[:interface]
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -17,11 +17,8 @@ module Fog
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # TODO This is ugly and needs to rethink mocks
-          unless Fog.mock?
-            raise Fog::Compute::Vsphere::NotFound, "Datacenter #{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
-            raise Fog::Compute::Vsphere::NotFound, "Template #{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
-          end
+          raise Fog::Compute::Vsphere::NotFound, "Datacenter #{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
+          raise Fog::Compute::Vsphere::NotFound, "Template #{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
           options
         end
       end
@@ -29,54 +26,55 @@ module Fog
       class Real
         include Shared
 
-        # Clones a VM from a template or existing machine on your vSphere 
-        # Server.  
+        # Clones a VM from a template or existing machine on your vSphere
+        # Server.
         #
         # ==== Parameters
         # * options<~Hash>:
-        #   * 'datacenter'<~String> - *REQUIRED* Datacenter name your cloning 
+        #   * 'datacenter'<~String> - *REQUIRED* Datacenter name your cloning
         #     in. Make sure this datacenter exists, should if you're using
         #     the clone function in server.rb model.
-        #   * 'template_path'<~String> - *REQUIRED* The path to the machine you 
+        #   * 'template_path'<~String> - *REQUIRED* The path to the machine you
         #     want to clone FROM. Relative to Datacenter (Example:
         #     "FolderNameHere/VMNameHere")
-        #   * 'name'<~String> - *REQUIRED* The VMName of the Destination  
+        #   * 'name'<~String> - *REQUIRED* The VMName of the Destination
         #   * 'dest_folder'<~String> - Destination Folder of where 'name' will
         #     be placed on your cluster. Relative Path to Datacenter E.G.
         #     "FolderPlaceHere/anotherSub Folder/onemore"
-        #   * 'power_on'<~Boolean> - Whether to power on machine after clone. 
+        #   * 'power_on'<~Boolean> - Whether to power on machine after clone.
         #     Defaults to true.
         #   * 'wait'<~Boolean> - Whether the method should wait for the virtual
-        #     machine to finish cloning before returning information from 
+        #     machine to finish cloning before returning information from
         #     vSphere. Broken right now as you cannot return a model of a serer
         #     that isn't finished cloning. Defaults to True
-        #   * 'resource_pool'<~Array> - The resource pool on your datacenter 
+        #   * 'resource_pool'<~Array> - The resource pool on your datacenter
         #     cluster you want to use. Only works with clusters within same
         #     same datacenter as where you're cloning from. Datacenter grabbed
-        #     from template_path option. 
+        #     from template_path option.
         #     Example: ['cluster_name_here','resource_pool_name_here']
         #   * 'datastore'<~String> - The datastore you'd like to use.
         #       (datacenterObj.datastoreFolder.find('name') in API)
         #   * 'transform'<~String> - Not documented - see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html
+        #   * 'numCPUs'<~Integer> - the number of Virtual CPUs of the Destination VM
+        #   * 'memoryMB'<~Integer> - the size of memory of the Destination VM in MB
         #   * customization_spec<~Hash>: Options are marked as required if you
         #     use this customization_spec. Static IP Settings not configured.
         #     This only support cloning and setting DHCP on the first interface
-        #     * 'domain'<~String> - *REQUIRED* This is put into 
+        #     * 'domain'<~String> - *REQUIRED* This is put into
         #       /etc/resolve.conf (we hope)
-        #     * 'hostname'<~String> - Hostname of the Guest Os - default is 
+        #     * 'hostname'<~String> - Hostname of the Guest Os - default is
         #       options['name']
-        #     * 'hw_utc_clock'<~Boolean> - *REQUIRED* Is hardware clock UTC? 
+        #     * 'hw_utc_clock'<~Boolean> - *REQUIRED* Is hardware clock UTC?
         #       Default true
-        #     * 'time_zone'<~String> - *REQUIRED* Only valid linux options 
+        #     * 'time_zone'<~String> - *REQUIRED* Only valid linux options
         #       are valid - example: 'America/Denver'
-        #
         def vm_clone(options = {})
           # Option handling
           options = vm_clone_check_options(options)
 
           # Added for people still using options['path']
           template_path = options['path'] || options['template_path']
-          
+
           # Default wait enabled
           options['wait'] = true
 
@@ -107,16 +105,17 @@ module Fog
           # 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
-          # This catches if resource_pool option is set but comes back nil and if resourcePool is 
-          # already set. 
+          # This catches if resource_pool option is set but comes back nil and if resourcePool is
+          # already set.
           resource_pool ||= vm_mob_ref.resourcePool.nil? ? esx_host.parent.resourcePool : vm_mob_ref.resourcePool
-                    
+
           # Options['datastore']<~String>
           # Grab the datastore object if option is set
           datastore_obj = get_raw_datastore(options['datastore'], options['datacenter']) if options.has_key?('datastore')
           # confirm nil if nil or option is not set
           datastore_obj ||= nil
-          
+          virtual_machine_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec()
+
           # Options['network']
           # Build up the config spec
           if ( options.has_key?('network_label') )
@@ -137,16 +136,38 @@ module Fog
             device_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
               :operation => config_spec_operation,
               :device => device)
-            virtual_machine_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec(
-              :deviceChange => [device_spec])
+            virtual_machine_config_spec.deviceChange = [device_spec]
           end
-          
+          # Options['numCPUs'] or Options['memoryMB']
+          # Build up the specification for Hardware, for more details see ____________
+          # https://github.com/rlane/rbvmomi/blob/master/test/test_serialization.rb
+          virtual_machine_config_spec.numCPUs = options['numCPUs'] if  ( options.has_key?('numCPUs') )
+          virtual_machine_config_spec.memoryMB = options['memoryMB'] if ( options.has_key?('memoryMB') )
           # Options['customization_spec']
           # Build up all the crappy tiered objects like the perl method
           # Collect your variables ifset (writing at 11pm revist me)
+          # * domain <~String> - *REQUIRED* - Sets the server's domain for customization
+          # * ipsettings <~Hash> - Optional - If not set defaults to dhcp
+          #  * ip <~String> - *REQUIRED* Sets the ip address of the VM - Example: 10.0.0.10
+          #  * dnsServerList <~Array> - Optional - Sets the nameservers in resolv - Example: ["10.0.0.2", "10.0.0.3"]
+          #  * gateway <~Array> - Optional - Sets the gateway for the interface - Example: ["10.0.0.1"]
+          #  * subnetMask <~String> - *REQUIRED* - Set the netmask of the interface - Example: "255.255.255.0"
+          #    For other ip settings options see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.customization.IPSettings.html
           if ( options.has_key?('customization_spec') )
             cust_options = options['customization_spec']
+            if cust_options.has_key?("ipsettings")
+              raise ArgumentError, "ip and subnetMask is required for static ip" unless cust_options["ipsettings"].has_key?("ip") and
+                                                                                        cust_options["ipsettings"].has_key?("subnetMask")
+            end
+            raise ArgumentError, "domain is required" unless cust_options.has_key?("domain")
             cust_domain = cust_options['domain']
+            cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(cust_options["ipsettings"]) if cust_options.has_key?("ipsettings")
+            cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp("ipAddress" => cust_options["ipsettings"]["ip"]) if cust_options.has_key?("ipsettings")
+            cust_ip_settings ||= RbVmomi::VIM::CustomizationIPSettings.new("ip" => RbVmomi::VIM::CustomizationDhcpIpGenerator.new())
+            cust_ip_settings.dnsDomain = cust_domain
+            cust_global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
+            cust_global_ip_settings.dnsServerList = cust_ip_settings.dnsServerList
+            cust_global_ip_settings.dnsSuffixList = [cust_domain]
             cust_hostname = RbVmomi::VIM::CustomizationFixedName.new(:name => cust_options['hostname']) if cust_options.has_key?('hostname')
             cust_hostname ||= RbVmomi::VIM::CustomizationFixedName.new(:name => options['name'])
             cust_hwclockutc = cust_options['hw_clock_utc']
@@ -158,20 +179,25 @@ module Fog
               :hostName => cust_hostname,
               :hwClockUTC => cust_hwclockutc,
               :timeZone => cust_timezone)
-            # Build the Dhcp Generator Object 
-            cust_fixed_ip = RbVmomi::VIM::CustomizationDhcpIpGenerator.new()
-            # Build the custom_ip_settings Object
-            cust_ip_setting = RbVmomi::VIM::CustomizationIPSettings.new(:ip => cust_fixed_ip)
             # Build the Custom Adapter Mapping Supports only one eth right now
-            cust_adapter_mapping = [RbVmomi::VIM::CustomizationAdapterMapping.new(:adapter => cust_ip_setting)]
+            cust_adapter_mapping = [RbVmomi::VIM::CustomizationAdapterMapping.new("adapter" => cust_ip_settings)]
             # Build the customization Spec
             customization_spec = RbVmomi::VIM::CustomizationSpec.new(
               :identity => cust_prep,
-              :globalIPSettings => RbVmomi::VIM::CustomizationGlobalIPSettings.new(),
+              :globalIPSettings => cust_global_ip_settings,
               :nicSettingMap => cust_adapter_mapping)
           end
           customization_spec ||= nil
-          
+
+          # FIXME: pad this out with the rest of the useful things in VirtualMachineConfigSpec
+          # http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.ConfigSpec.html
+          if options.has_key?('memoryMB') || options.has_key?('numCPUs')
+            virtual_machine_config_spec = {
+              :memoryMB => options['memoryMB'],
+              :numCPUs  => options['numCPUs']
+            }
+          end
+
           relocation_spec=nil
           if ( options['linked_clone'] )
             # cribbed heavily from the rbvmomi clone_vm.rb
@@ -206,7 +232,7 @@ module Fog
                                                                       :pool => resource_pool,
                                                                       :diskMoveType => :moveChildMostDiskBacking)
           else
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj, 
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj,
                                                                       :pool => resource_pool,
                                                                       :transform => options['transform'] || 'sparse')
           end
@@ -216,7 +242,7 @@ module Fog
                                                             :customization => customization_spec,
                                                             :powerOn  => options.has_key?('power_on') ? options['power_on'] : true,
                                                             :template => false)
-          
+
           # Perform the actual Clone Task
           task = vm_mob_ref.CloneVM_Task(:folder => dest_folder,
                                          :name => options['name'],
@@ -245,7 +271,7 @@ module Fog
               nil
             end
           end
-          
+
           # Return hash
           {
             'vm_ref'        => new_vm ? new_vm._ref : nil,
@@ -262,21 +288,24 @@ module Fog
           # Option handling TODO Needs better method of checking
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
-          list_virtual_machines.find(notfound) do |vm|
-            vm[:name] == options['template_path'].split("/")[-1]
+          template = list_virtual_machines.find(notfound) do |vm|
+            vm['name'] == options['template_path'].split("/")[-1]
           end
+
+          # generate a random id
+          id = [8,4,4,4,12].map{|i| Fog::Mock.random_hex(i)}.join("-")
+          new_vm = template.clone.merge({
+            "name" => options['name'],
+            "id" => id,
+            "instance_uuid" => id,
+            "path" => "/Datacenters/#{options['datacenter']}/#{options['dest_folder'] ? options['dest_folder']+"/" : ""}#{options['name']}"
+          })
+          self.data[:servers][id] = new_vm
+
           {
-            'vm_ref'   => 'vm-123',
-            'new_vm'   => {
-              "id"=>"vm-123", "name"=>"fog-vm", "uuid"=>"421169de-a984-2d68-f995-939c01904009",
-              "hostname"=>nil, "operatingsystem"=>nil, "ipaddress"=>nil, "power_state"=>"poweredOn",
-              "connection_state"=>"connected", "hypervisor"=>"hy.acme.com", "tools_state"=>"toolsNotRunning",
-              "tools_version"=>"guestToolsUnmanaged", "memory_mb"=>1024, "cpus"=>1,
-              "overall_status"=>"green", "guest_id"=>nil, "mo_ref"=>"vm-49714", "datacenter"=>"Solutions",
-              "cluster"=>"Cluster1", "resource_pool"=>"Resources",
-              "mac_addresses"=>{"Network adapter 1"=>"00:50:56:91:54:ba"},
-              "path"=>"/Datacenters/Solutions/vm", "relative_path"=>""},
-            'task_ref' => 'task-1234',
+            'vm_ref'   => "vm-#{Fog::Mock.random_numbers(3)}",
+            'new_vm'   => new_vm,
+            'task_ref' => "task-#{Fog::Mock.random_numbers(4)}",
           }
         end