class Fog::Compute::Vsphere::Real

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/vsphere/compute.rb, line 374
def initialize(options={})
  require 'rbvmomi'
  @vsphere_username = options[:vsphere_username]
  @vsphere_password = options[:vsphere_password]
  @vsphere_server   = options[:vsphere_server]
  @vsphere_port     = options[:vsphere_port] || 443
  @vsphere_path     = options[:vsphere_path] || '/sdk'
  @vsphere_ns       = options[:vsphere_ns] || 'urn:vim25'
  @vsphere_rev      = options[:vsphere_rev] || '4.0'
  @vsphere_ssl      = options[:vsphere_ssl] || true
  @vsphere_expected_pubkey_hash = options[:vsphere_expected_pubkey_hash]
  @vsphere_must_reauthenticate = false
  @vsphere_is_vcenter = nil
  @connection = nil
  connect
  negotiate_revision(options[:vsphere_rev])
  authenticate
end

Public Instance Methods

add_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 5
def add_vm_interface(vmid, options = {})
  raise ArgumentError, "instance id is a required parameter" unless vmid

  interface = get_interface_from_options(vmid, options.merge(:server_id => vmid))
  vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, 0, :add, options)]})
end
add_vm_volume(volume) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_volume.rb, line 5
def add_vm_volume(volume)
  vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :add)]})
end
cloudinit_to_customspec(user_data) click to toggle source
# File lib/fog/vsphere/requests/compute/cloudinit_to_customspec.rb, line 5
def cloudinit_to_customspec(user_data)
  raise ArgumentError, "user_data can't be nil" if user_data.nil?
  custom_spec = { 'customization_spec' => Hash.new }
  user_data = YAML.load(user_data)
  custom_spec['hostname']                    =  user_data['hostname'] if user_data.key?('hostname')
  custom_spec['ipsettings']                  =  { 'ip' => user_data['ip'] } if user_data.key?('ip')
  custom_spec['ipsettings']['subnetMask']    =  user_data['netmask'] if user_data.key?('netmask')
  custom_spec['ipsettings']['dnsServerList'] =  user_data['dns'] if user_data.key?('dns')
  custom_spec['domain']                      =  user_data['domain'] if user_data.key?('domain')
  custom_spec['dnsSuffixList']               =  user_data['domain'] if user_data.key?('domain')
  custom_spec['time_zone']                   =  user_data['timezone'] if user_data.key?('timezone')
  custom_spec           
end
create_folder(datacenter, path, name) click to toggle source
# File lib/fog/vsphere/requests/compute/create_folder.rb, line 5
def create_folder(datacenter, path, name)
  #Path cannot be nil but it can be an empty string
  raise ArgumentError, "Path cannot be nil" if path.nil?

  parent_folder = get_raw_vmfolder(path, datacenter)
  begin
    new_folder = parent_folder.CreateFolder(:name => name)
    # output is cleaned up to return the new path
    # new path will be path/name, example: "Production/Pool1"
    new_folder.path.reject { |a| a.first.class == "Folder" }.map { |a| a.first.name }.join("/").sub(/^\/?Datacenters\/#{datacenter}\/vm\/?/, '')
  rescue => e
    raise e, "failed to create folder: #{e}"
  end
end
create_vm(attributes = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 5
def create_vm attributes = { }
  # build up vm configuration

  vm_cfg        = {
    :name         => attributes[:name],
    :guestId      => attributes[:guest_id],
    :version      => attributes[:hardware_version],
    :files        => { :vmPathName => vm_path_name(attributes) },
    :numCPUs      => attributes[:cpus],
    :numCoresPerSocket => attributes[:corespersocket],
    :memoryMB     => attributes[:memory_mb],
    :deviceChange => device_change(attributes),
    :extraConfig  => extra_config(attributes),
  }
  resource_pool = if attributes[:resource_pool]
                    get_raw_resource_pool(attributes[:resource_pool], attributes[:cluster], attributes[:datacenter])
                  else
                    get_raw_cluster(attributes[:cluster], attributes[:datacenter]).resourcePool
                  end
  vmFolder      = get_raw_vmfolder(attributes[:path], attributes[:datacenter])
  vm            = vmFolder.CreateVM_Task(:config => vm_cfg, :pool => resource_pool).wait_for_completion
  vm.config.instanceUuid
rescue => e
  raise e, "failed to create vm: #{e}"
end
current_time() click to toggle source
# File lib/fog/vsphere/requests/compute/current_time.rb, line 5
def current_time
  current_time = @connection.serviceInstance.CurrentTime
  { 'current_time' => current_time }
end
destroy_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 12
def destroy_vm_interface(vmid, options = {})
  raise ArgumentError, "instance id is a required parameter" unless vmid

  interface = get_interface_from_options(vmid, options.merge(:server_id => vmid))
  vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, interface.key, :remove)]})
end
destroy_vm_volume(volume) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_volume.rb, line 9
def destroy_vm_volume(volume)
  vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :remove)]})
end
get_cluster(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_cluster.rb, line 5
def get_cluster(name, datacenter_name)
  cluster = get_raw_cluster(name, datacenter_name)
  raise(Fog::Compute::Vsphere::NotFound) unless cluster
  cluster_attributes(cluster, datacenter_name)
end
get_compute_resource(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_compute_resource.rb, line 5
def get_compute_resource(name, datacenter_name)
  compute_resource = get_raw_compute_resource(name, datacenter_name)
  raise(Fog::Compute::Vsphere::NotFound) unless compute_resource
  compute_resource_attributes(compute_resource, datacenter_name)
end
get_datacenter(name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datacenter.rb, line 5
def get_datacenter name
  dc = find_raw_datacenter(name)
  raise(Fog::Compute::Vsphere::NotFound) unless dc
  {:name => dc.name, :status => dc.overallStatus, :path => raw_getpathmo(dc) }
end
get_datastore(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datastore.rb, line 5
def get_datastore(name, datacenter_name)
  datastore = get_raw_datastore(name, datacenter_name)
  raise(Fog::Compute::Vsphere::NotFound) unless datastore
  datastore_attributes(datastore, datacenter_name)
end
get_folder(path, datacenter_name, type = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_folder.rb, line 5
def get_folder(path, datacenter_name, type = nil)
  type ||= 'vm'

  # Cycle through all types of folders.
  case type
    when 'vm', :vm
      # if you're a vm then grab the VM.
      folder = get_raw_vmfolder(path, datacenter_name)
      raise(Fog::Compute::Vsphere::NotFound) unless folder
      folder_attributes(folder, datacenter_name)
    when 'network', :network
      raise "not implemented"
    when 'datastore', :datastore
      raise "not implemented"
    else
      raise ArgumentError, "#{type} is unknown"
  end
end
get_interface_type(id, servertype, datacenter, filter={}) click to toggle source
# File lib/fog/vsphere/requests/compute/get_interface_type.rb, line 5
def get_interface_type(id, servertype, datacenter, filter={})
   interfacetype=list_interface_types(filters={:id => id,
     :datacenter => datacenter,
     :servertype => servertype.id }).first
   raise(Fog::Compute::Vsphere::NotFound) unless interfacetype
   interfacetype
end
get_network(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_network.rb, line 5
def get_network(name, datacenter_name)
  network = get_raw_network(name, datacenter_name)
  raise(Fog::Compute::Vsphere::NotFound) unless network
  network_attributes(network, datacenter_name)
end
get_resource_pool(name, cluster_name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_resource_pool.rb, line 5
def get_resource_pool(name, cluster_name, datacenter_name)
  resource_pool = get_raw_resource_pool(name, cluster_name, datacenter_name)
  raise(Fog::Compute::Vsphere::NotFound) unless resource_pool
  resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
end
get_server_type(id, datacenter, filter={}) click to toggle source
# File lib/fog/vsphere/requests/compute/get_server_type.rb, line 5
def get_server_type(id, datacenter, filter={})
  server_type=get_raw_server_type(id, datacenter)
  raise(Fog::Compute::Vsphere::NotFound) unless server_type
  server_type_attributes(server_type, datacenter)
end
get_template(id, datacenter_name = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_template.rb, line 5
def get_template(id, datacenter_name = nil)
  convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
end
get_virtual_machine(id, datacenter_name = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_virtual_machine.rb, line 5
def get_virtual_machine(id, datacenter_name = nil)
  # The larger the VM list the longer it will take if not searching based on UUID.
  convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
end
get_vm_first_scsi_controller(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/get_vm_first_scsi_controller.rb, line 6
def get_vm_first_scsi_controller(vm_id)
  Fog::Compute::Vsphere::SCSIController.new(get_vm_first_scsi_controller_raw(vm_id))
end
get_vm_first_scsi_controller_raw(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/get_vm_first_scsi_controller.rb, line 10
def get_vm_first_scsi_controller_raw(vm_id)
  ctrl=get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).select{ | ctrl | ctrl.key == 1000 }.first
  {
    :type    => ctrl.class.to_s,
    :shared_bus  => ctrl.sharedBus.to_s,
    :unit_number => ctrl.scsiCtlrUnitNumber,
    :key => ctrl.key,
  }
end
get_vm_interface(vm_id, options={}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_interfaces.rb, line 45
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.key? :key or options.key? :mac or options.key? :name
    list_vm_interfaces(vm_id).find do | nic |
      (options.key? :key and nic[:key]==options[:key].to_i) or (options.key? :mac and nic[:mac]==options[:mac]) or (options.key? :name and nic[:name]==options[:name])
    end
  end
end
interface_type_attributes(nic, servertype, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_interface_types.rb, line 14
def interface_type_attributes(nic, servertype, datacenter)
  {
    :id => nic,
    :name => nic,
    :datacenter => datacenter,
    :servertype => servertype
  }
end
list_clusters(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 5
def list_clusters(filters = { })
  datacenter_name = filters[:datacenter]

  raw_clusters(datacenter_name).map do |cluster|
    cluster_attributes(cluster, datacenter_name)
  end
end
list_compute_resources(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_compute_resources.rb, line 5
def list_compute_resources(filters = { })
  datacenter_name = filters[:datacenter]
  # default to show all compute_resources
  only_active = filters[:effective] || false
  compute_resources = raw_compute_resources datacenter_name
  
  compute_resources.map do |compute_resource|
    summary = compute_resource.summary
    next if only_active and summary.numEffectiveHosts == 0
    compute_resource_attributes(compute_resource, datacenter_name)
  end.compact
end
list_customfields() click to toggle source
# File lib/fog/vsphere/requests/compute/list_customfields.rb, line 5
def list_customfields()
  @connection.serviceContent.customFieldsManager.field.map do |customfield|
    {
      :key   => customfield.key.to_i,
      :name  => customfield.name,
      :type  => customfield.type
    }
  end
end
list_datacenters(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 5
def list_datacenters filters = {}
  raw_datacenters.map do |dc|
    {
      :id => managed_obj_id(dc),
      :name => dc.name,
      :path => raw_getpathmo(dc),
      :status => dc.overallStatus
    }
  end
end
list_datastores(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datastores.rb, line 5
def list_datastores(filters = { })
  datacenter_name = filters[:datacenter]
  # default to show all datastores
  only_active = filters[:accessible] || false
  raw_datastores(datacenter_name).map do |datastore|
    next if only_active and !datastore.summary.accessible
    datastore_attributes(datastore, datacenter_name)
  end.compact
end
list_folders(filters = { }) click to toggle source

Grabs all sub folders within a given path folder.

Parameters

  • filters<~Hash>:

    • :datacenter<~String> - REQUIRED Your datacenter where you're looking for folders. Example: 'my-datacenter-name' (passed if you are using the models/collections)

      eg: vspconn.datacenters.first.vm_folders('mypath')
    • :path<~String> - Your path where you're looking for more folders, if return = none you will get an error. If you don't define it will look in the main datacenter folder for any folders in that datacenter.

Example Usage Testing Only:

vspconn = Fog::Compute[:vsphere]
mydc = vspconn.datacenters.first
folders = mydc.vm_folders
# File lib/fog/vsphere/requests/compute/list_folders.rb, line 23
def list_folders(filters = { })
  path            = filters[:path] || filters['path'] || ''
  datacenter_name = filters[:datacenter]
  get_raw_vmfolders(path, datacenter_name).map do |folder|
    folder_attributes(folder, datacenter_name)
  end
end
list_interface_types(filters={}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_interface_types.rb, line 5
def list_interface_types(filters={})
  datacenter_name = filters[:datacenter]
  servertype_name = filters[:servertype]
  get_raw_server_type(servertype_name, datacenter_name)[:supportedEthernetCard].map do | nictype |
    next if filters.key?(:id) and filters[:id] != nictype
    interface_type_attributes(nictype, servertype_name, datacenter_name)
  end.compact
end
list_networks(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_networks.rb, line 5
def list_networks(filters = { })
  datacenter_name = filters[:datacenter]
  # default to show all networks
  only_active = filters[:accessible] || false
  raw_networks(datacenter_name).map do |network|
    next if only_active and !network.summary.accessible
    network_attributes(network, datacenter_name)
  end.compact
end
list_resource_pools(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_resource_pools.rb, line 5
def list_resource_pools(filters = { })
  datacenter_name = filters[:datacenter]
  cluster_name    = filters[:cluster]
  cluster         = get_raw_cluster(cluster_name, datacenter_name)
  list_raw_resource_pools(cluster).map do |resource_pool|
    resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
  end
end
list_server_types(filters={}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_server_types.rb, line 5
def list_server_types(filters={})
  datacenter_name = filters[:datacenter]
  servertypes=raw_server_types(datacenter_name)
  if servertypes
    servertypes.map do | servertype |
       server_type_attributes(servertype, datacenter_name)
    end.compact
  else
    nil
  end
  #select{ | guestdesc | guestdesc.select{ | k, v | filter.has_key?(k) and filter[k] == v }==filter }
end
list_templates(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_templates.rb, line 5
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
list_virtual_machines(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 5
def list_virtual_machines(options = { })
  # 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.

  options[:folder] ||= options['folder']
  if options['instance_uuid'] then
    [get_virtual_machine(options['instance_uuid'])]
  elsif options[:folder] && options[:datacenter] then
    list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
  else
    list_all_virtual_machines(options)
  end
end
list_vm_customvalues(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_customvalues.rb, line 5
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
list_vm_interfaces(vm_id) click to toggle source
=> VirtualE1000(

addressType: “assigned”, backing: VirtualEthernetCardNetworkBackingInfo(

deviceName: "VM Network",
dynamicProperty: [],
network: Network("network-163"),
useAutoDetect: false

), connectable: VirtualDeviceConnectInfo(

allowGuestControl: true,
connected: true,
dynamicProperty: [],
startConnected: true,
status: "ok"

), controllerKey: 100, deviceInfo: Description(

dynamicProperty: [],
label: "Network adapter 1",
summary: "VM Network"

), dynamicProperty: [], key: 4000, macAddress: “00:50:56:a9:00:28”, unitNumber: 7,

# File lib/fog/vsphere/requests/compute/list_vm_interfaces.rb, line 31
def list_vm_interfaces(vm_id)
  get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).map do |nic|
    {
      :name    => nic.deviceInfo.label,
      :mac     => nic.macAddress,
      :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
list_vm_volumes(vm_id) click to toggle source
[VirtualDisk(
 backing: VirtualDiskFlatVer2BackingInfo(
   contentId: "a172d19487e878e17d6b16ff2505d7eb",
   datastore: Datastore("datastore-162"),
   diskMode: "persistent",
   dynamicProperty: [],
   fileName: "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
   split: false,
   thinProvisioned: true,
   uuid: "6000C29c-a47d-4cd9-5249-c371de775f06",
   writeThrough: false
 ),
 capacityInKB: 8388608,
 controllerKey: 1000,
 deviceInfo: Description(
   dynamicProperty: [],
   label: "Hard disk 1",
   summary: "8,388,608 KB"
 ),
 dynamicProperty: [],
 key: 2001,
 shares: SharesInfo( dynamicProperty: [], level: "normal", shares: 1000 ),
 unitNumber: 1

)]

# File lib/fog/vsphere/requests/compute/list_vm_volumes.rb, line 30
def list_vm_volumes(vm_id)
  get_vm_ref(vm_id).disks.map do |vol|
    {
      :id => vol.backing.uuid,
      :thin => (vol.backing.thinProvisioned rescue(nil)),
      :mode => vol.backing.diskMode,
      :filename => vol.backing.fileName,
      :datastore => (vol.backing.datastore.name rescue(nil)),
      :size => vol.capacityInKB,
      :name => vol.deviceInfo.label,
      :key => vol.key,
      :unit_number => vol.unitNumber
    }
  end
end
raw_clusters(datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 13
def raw_clusters(datacenter)
  folder ||= find_raw_datacenter(datacenter).hostFolder
  @raw_clusters = get_raw_clusters_from_folder(folder)
end
raw_compute_resources(datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_compute_resources.rb, line 18
def raw_compute_resources(datacenter_name)
  find_raw_datacenter(datacenter_name).find_compute_resource('').children
end
raw_datastores(datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datastores.rb, line 15
def raw_datastores(datacenter_name)
  find_raw_datacenter(datacenter_name).datastore
end
raw_networks(datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_networks.rb, line 15
def raw_networks(datacenter_name)
  find_raw_datacenter(datacenter_name).network
end
raw_server_types(datacenter_name, filter={}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_server_types.rb, line 18
def raw_server_types(datacenter_name, filter={})
  datacenter=find_raw_datacenter(datacenter_name)
  environmentBrowser=datacenter.hostFolder.childEntity.grep(RbVmomi::VIM::ComputeResource).first.environmentBrowser
  if environmentBrowser
    environmentBrowser.QueryConfigOption[:guestOSDescriptor]
  end
end
reload() click to toggle source
# File lib/fog/vsphere/compute.rb, line 393
def reload
  connect
  # Check if the negotiation was ever run
  if @vsphere_is_vcenter.nil?
    negotiate
  end
  authenticate
end
set_vm_customvalue(vm_id, key, value) click to toggle source
# File lib/fog/vsphere/requests/compute/set_vm_customvalue.rb, line 5
def set_vm_customvalue(vm_id, key, value)
  vm_ref = get_vm_ref(vm_id)
  vm_ref.setCustomValue(:key => key, :value => value)
end
update_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 19
def update_vm_interface(vmid, options = {})
  raise ArgumentError, "instance id is a required parameter" unless vmid

  interface = get_interface_from_options(vmid, options.merge(:server_id => vmid))
  vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, interface.key, :edit)]})
end
vm_clone(options = {}) click to toggle source

Clones a VM from a template or existing machine on your vSphere Server.

Parameters

  • options<~Hash>:

    • '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 want to clone FROM. Relative to Datacenter (Example: “FolderNameHere/VMNameHere”)

    • '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. Defaults to true.

    • 'wait'<~Boolean> - Whether the method should wait for the virtual 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 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. 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 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 /etc/resolve.conf (we hope)

      • 'hostname'<~String> - Hostname of the Guest Os - default is options

      • 'hw_utc_clock'<~Boolean> - REQUIRED Is hardware clock UTC? Default true

      • 'time_zone'<~String> - REQUIRED Only valid linux options are valid - example: 'America/Denver'

# File lib/fog/vsphere/requests/compute/vm_clone.rb, line 71
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']

  # Options['template_path']<~String>
  # Added for people still using options['path']
  template_path = options['path'] || options['template_path']
  # Now find the template itself using the efficient find method
  vm_mob_ref = get_vm_ref(template_path, options['datacenter'])

  # Options['dest_folder']<~String>
  # Grab the destination folder object if it exists else use cloned mach
  dest_folder_path = options.fetch('dest_folder','/') # default to root path ({dc_name}/vm/)
  dest_folder = get_raw_vmfolder(dest_folder_path, options['datacenter'])

  # Options['resource_pool']<~Array>
  # Now find _a_ resource pool to use for the clone if one is not specified
  if ( options.key?('resource_pool') && options['resource_pool'].is_a?(Array) && options['resource_pool'].length == 2 )
    cluster_name = options['resource_pool'][0]
    pool_name = options['resource_pool'][1]
    resource_pool = get_raw_resource_pool(pool_name, cluster_name, options['datacenter'])
  elsif ( 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
  end
  # 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.
  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.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.key?('network_label') )
    #network_obj = datacenter_obj.networkFolder.find(options['network_label'])
    config_spec_operation = RbVmomi::VIM::VirtualDeviceConfigSpecOperation('edit')
    nic_backing_info = RbVmomi::VIM::VirtualEthernetCardNetworkBackingInfo(:deviceName => options['network_label'])
      #:deviceName => "Network adapter 1",
      #:network => network_obj)
    connectable = RbVmomi::VIM::VirtualDeviceConnectInfo(
      :allowGuestControl => true,
      :connected => true,
      :startConnected => true)
    device = RbVmomi::VIM.public_send "#{options['nic_type']}",
      :backing => nic_backing_info,
      :deviceInfo => RbVmomi::VIM::Description(:label => "Network adapter 1", :summary => options['network_label']),
      :key => options['network_adapter_device_key'],
      :connectable => connectable
    device_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
      :operation => config_spec_operation,
      :device => device)
    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
  # http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.ConfigSpec.html
  # FIXME: pad this out with the rest of the useful things in VirtualMachineConfigSpec
  virtual_machine_config_spec.numCPUs = options['numCPUs'] if  ( options.key?('numCPUs') )
  virtual_machine_config_spec.memoryMB = options['memoryMB'] if ( options.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
  # * dnsSuffixList <~Array> - Optional - Sets the dns search paths in resolv - Example: ["dev.example.com", "example.com"]
  # * 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.key?('customization_spec') )
    cust_options = options['customization_spec']
    if cust_options.key?("ipsettings")
      raise ArgumentError, "ip and subnetMask is required for static ip" unless cust_options["ipsettings"].key?("ip") and
                                                                                cust_options["ipsettings"].key?("subnetMask")
    end
    raise ArgumentError, "domain is required" unless cust_options.key?("domain")
    cust_domain = cust_options['domain']
    cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(cust_options["ipsettings"]) if cust_options.key?("ipsettings")
    cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp("ipAddress" => cust_options["ipsettings"]["ip"]) if cust_options.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_options['dnsSuffixList'] || [cust_domain]
    cust_hostname = RbVmomi::VIM::CustomizationFixedName.new(:name => cust_options['hostname']) if cust_options.key?('hostname')
    cust_hostname ||= RbVmomi::VIM::CustomizationFixedName.new(:name => options['name'])
    cust_hwclockutc = cust_options['hw_clock_utc']
    cust_timezone = cust_options['time_zone']
    # Start Building objects
    # Build the CustomizationLinuxPrep Object
    cust_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
      :domain => cust_domain,
      :hostName => cust_hostname,
      :hwClockUTC => cust_hwclockutc,
      :timeZone => cust_timezone)
    # Build the Custom Adapter Mapping Supports only one eth right now
    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 => cust_global_ip_settings,
      :nicSettingMap => cust_adapter_mapping)
  end
  customization_spec ||= nil

  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(:datastore => datastore_obj,
                                                              :pool => resource_pool,
                                                              :diskMoveType => :moveChildMostDiskBacking)
  else
    relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj,
                                                              :pool => resource_pool,
                                                              :transform => options['transform'] || 'sparse')
  end
  # And the clone specification
  clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
                                                    :config => virtual_machine_config_spec,
                                                    :customization => customization_spec,
                                                    :powerOn  => options.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'],
                                 :spec => clone_spec)
  # 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.fetch('wait', true) 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)
      dest_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

  # Return hash
  {
    'vm_ref'        => new_vm ? new_vm._ref : nil,
    'new_vm'        => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : nil,
    'task_ref'      => task._ref
  }
end
vm_config_vnc(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_config_vnc.rb, line 5
def vm_config_vnc(options = { })
  raise ArgumentError, "instance_uuid is a required parameter" unless options.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
vm_destroy(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_destroy.rb, line 5
def vm_destroy(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'

  vm_mob_ref = get_vm_ref(options['instance_uuid'])
  task = vm_mob_ref.Destroy_Task
  task.wait_for_completion
  { 'task_state' => task.info.state }
end
vm_get_vnc(uuid) click to toggle source

return a hash of VNC attributes required to view the console

# File lib/fog/vsphere/requests/compute/vm_config_vnc.rb, line 22
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
vm_migrate(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_migrate.rb, line 5
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.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
vm_power_off(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_power_off.rb, line 5
def vm_power_off(options = {})
  options = { 'force' => false }.merge(options)
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'

  search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
  vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first

  if options['force'] then
    task = vm_mob_ref.PowerOffVM_Task
    task.wait_for_completion
    { 'task_state' => task.info.result, 'power_off_type' => 'cut_power' }
  else
    vm_mob_ref.ShutdownGuest
    {
      'task_state'     => "running",
      'power_off_type' => 'shutdown_guest',
    }
  end
end
vm_power_on(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_power_on.rb, line 5
def vm_power_on(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.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.PowerOnVM_Task
  task.wait_for_completion
  # 'success', 'running', 'queued', 'error'
  { 'task_state' => task.info.state }
end
vm_reboot(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reboot.rb, line 5
def vm_reboot(options = {})
  options = { 'force' => false }.merge(options)
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'

  search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
  vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first

  if options['force'] then
    task = vm_mob_ref.ResetVM_Task
    task.wait_for_completion
    { 'task_state' => task.info.result, 'reboot_type' => 'reset_power' }
  else
    vm_mob_ref.RebootGuest
    { 'task_state' => "running", 'reboot_type' => 'reboot_guest' }
  end
end
vm_reconfig_cpus(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_cpus.rb, line 5
def vm_reconfig_cpus(options = {})
  raise ArgumentError, "cpus is a required parameter" unless options.key? 'cpus'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  hardware_spec={'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket']}
  vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
end
vm_reconfig_hardware(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_hardware.rb, line 5
def vm_reconfig_hardware(options = {})
  raise ArgumentError, "hardware_spec is a required parameter" unless options.key? 'hardware_spec'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  vm_mob_ref = get_vm_ref(options['instance_uuid'])
  task = vm_mob_ref.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
  task.wait_for_completion
   { 'task_state' => task.info.state }
end
vm_reconfig_memory(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_memory.rb, line 5
def vm_reconfig_memory(options = {})
  raise ArgumentError, "memory is a required parameter" unless options.key? 'memory'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  hardware_spec={'memoryMB' => options['memory']}
  vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
end

Protected Instance Methods

child_folders(folder) click to toggle source
# File lib/fog/vsphere/requests/compute/list_folders.rb, line 38
def child_folders folder
  [folder, folder.childEntity.grep(RbVmomi::VIM::Folder).map(&method(:child_folders)).flatten]
end
cluster_attributes(cluster, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 30
def cluster_attributes cluster, datacenter_name
  {
    :id             => managed_obj_id(cluster),
    :name           => cluster.name,
    :full_path      => cluster_path(cluster, datacenter_name),
    :num_host       => cluster.summary.numHosts,
    :num_cpu_cores  => cluster.summary.numCpuCores,
    :overall_status => cluster.summary.overallStatus,
    :datacenter     => datacenter_name || parent_attribute(cluster.path, :datacenter)[1],
  }
end
cluster_path(cluster, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 42
def cluster_path(cluster, datacenter_name)
  datacenter = find_raw_datacenter(datacenter_name)
  cluster.pretty_path.gsub(/(#{datacenter.name}|#{datacenter.hostFolder.name})\//,'')
end
compute_resource_attributes(compute_resource, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_compute_resources.rb, line 24
def compute_resource_attributes compute_resource, datacenter
  overall_usage = compute_resource.host.inject({:overallCpuUsage=>0, :overallMemoryUsage=>0}) do |sum, host|
    {
      :overallCpuUsage => sum[:overallCpuUsage]+(host.summary.quickStats.overallCpuUsage || 0), 
      :overallMemoryUsage=> sum[:overallMemoryUsage]+(host.summary.quickStats.overallMemoryUsage || 0)
    }
  end
  {
    :id                 =>   managed_obj_id(compute_resource),
    :name               =>   compute_resource.name,
    :totalCpu           =>   compute_resource.summary.totalCpu, 
    :totalMemory        =>   compute_resource.summary.totalMemory,
    :numCpuCores        =>   compute_resource.summary.numCpuCores, 
    :numCpuThreads      =>   compute_resource.summary.numCpuThreads,
    :effectiveCpu       =>   compute_resource.summary.effectiveCpu,
    :effectiveMemory    =>   compute_resource.summary.effectiveMemory,
    :numHosts           =>   compute_resource.summary.numHosts,
    :numEffectiveHosts  =>   compute_resource.summary.numEffectiveHosts,
    :overallStatus      =>   compute_resource.summary.overallStatus,
    :overallCpuUsage    =>   overall_usage[:overallCpuUsage],
    :overallMemoryUsage =>   overall_usage[:overallMemoryUsage],
    :effective          =>   compute_resource.summary.numEffectiveHosts > 0,
    :isSingleHost       =>   compute_resource.summary.numHosts == 1
  }
end
datastore_attributes(datastore, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datastores.rb, line 20
def datastore_attributes datastore, datacenter
  {
    :id          => managed_obj_id(datastore),
    :name        => datastore.name,
    :accessible  => datastore.summary.accessible,
    :type        => datastore.summary.type,
    :freespace   => datastore.summary.freeSpace,
    :capacity    => datastore.summary.capacity,
    :uncommitted => datastore.summary.uncommitted,
    :datacenter  => datacenter,
  }
end
find_datacenters(name=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 41
def find_datacenters name=nil
  name ? [find_raw_datacenter(name)] : raw_datacenters
end
find_raw_datacenter(name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datacenter.rb, line 13
def find_raw_datacenter name
  raw_datacenters.find {|d| d.name == name} ||  get_raw_datacenter(name)
end
folder_attributes(folder, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_folder.rb, line 49
def folder_attributes(folder, datacenter_name)
  {
    :id         => managed_obj_id(folder),
    :name       => folder.name,
    :parent     => folder.parent.name,
    :datacenter => datacenter_name,
    :type       => folder_type(folder),
    :path       => "/"+folder.path.map(&:last).join('/'),
  }
end
folder_type(folder) click to toggle source
# File lib/fog/vsphere/requests/compute/get_folder.rb, line 60
def folder_type(folder)
  types = folder.childType
  return :vm        if types.include?('VirtualMachine')
  return :network   if types.include?('Network')
  return :datastore if types.include?('Datastore')
end
get_raw_cluster(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_cluster.rb, line 13
def get_raw_cluster(name, datacenter_name)
  dc = find_raw_datacenter(datacenter_name)
  dc.find_compute_resource(name)
end
get_raw_clusters_from_folder(folder) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 20
def get_raw_clusters_from_folder(folder)
  folder.childEntity.map do |child_entity|
    if child_entity.is_a? RbVmomi::VIM::ComputeResource
      child_entity
    elsif child_entity.is_a? RbVmomi::VIM::Folder
      get_raw_clusters_from_folder(child_entity)
    end
  end.flatten
end
get_raw_compute_resource(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_compute_resource.rb, line 13
def get_raw_compute_resource(name, datacenter_name)
  find_raw_datacenter(datacenter_name).find_compute_resource(name)
end
get_raw_datacenter(name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datacenter.rb, line 17
def get_raw_datacenter name
  @connection.serviceInstance.find_datacenter(name)
end
get_raw_datacenters_from_folder(folder=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 31
def get_raw_datacenters_from_folder folder=nil
  folder.childEntity.map do | childE |
    if childE.is_a? RbVmomi::VIM::Datacenter
       childE
    elsif childE.is_a? RbVmomi::VIM::Folder
       get_raw_datacenters_from_folder childE
    end
  end.flatten
end
get_raw_datastore(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datastore.rb, line 13
def get_raw_datastore(name, datacenter_name)
  dc = find_raw_datacenter(datacenter_name)

  @connection.serviceContent.viewManager.CreateContainerView({
    :container  => dc.datastoreFolder,
    :type       =>  ["Datastore"],
    :recursive  => true
  }).view.select{|ds| ds.name == name}.first
end
get_raw_network(name, datacenter_name, distributedswitch=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_network.rb, line 13
def get_raw_network(name, datacenter_name, distributedswitch=nil)
  finder = choose_finder(name, distributedswitch)
  networks = get_all_raw_networks(datacenter_name)
  networks.find { |n| finder.call(n) }
end
get_raw_resource_pool(name, cluster_name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_resource_pool.rb, line 13
def get_raw_resource_pool(name, cluster_name, datacenter_name)
  dc      = find_raw_datacenter(datacenter_name)
  cluster = dc.find_compute_resource(cluster_name)
  name.nil? ? cluster.resourcePool : cluster.resourcePool.find( name)
end
get_raw_server_type(id, datacenter, filter={}) click to toggle source
# File lib/fog/vsphere/requests/compute/get_server_type.rb, line 13
def get_raw_server_type(id, datacenter, filter={})
   types=raw_server_types(datacenter)
   raise(Fog::Compute::Vsphere::NotFound) unless types
   types=types.select{ | servertype | servertype.id == id }.first
   raise(Fog::Compute::Vsphere::NotFound) unless types
   types
end
get_raw_vmfolder(path, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_folder.rb, line 26
def get_raw_vmfolder(path, datacenter_name)
  # The required path syntax - 'topfolder/subfolder

  # Clean up path to be relative since we're providing datacenter name
  dc             = find_raw_datacenter(datacenter_name)
  dc_root_folder = dc.vmFolder
  # Filter the root path for this datacenter not to be used."
  dc_root_folder_path=dc_root_folder.path.map { | id, name | name }.join("/")
  paths          = path.sub(/^\/?#{Regexp.quote(dc_root_folder_path)}\/?/, '').split('/')

  return dc_root_folder if paths.empty?
  # Walk the tree resetting the folder pointer as we go
  paths.reduce(dc_root_folder) do |last_returned_folder, sub_folder|
    # 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 = last_returned_folder.find(sub_folder, RbVmomi::VIM::Folder)
    raise ArgumentError, "Could not descend into #{sub_folder}.  Please check your path. #{path}" unless sub
    sub
  end
end
get_raw_vmfolders(path, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_folders.rb, line 33
def get_raw_vmfolders(path, datacenter_name)
  folder = get_raw_vmfolder(path, datacenter_name)
  child_folders(folder).flatten.compact
end
get_vm_by_name(name, dc) click to toggle source
# File lib/fog/vsphere/requests/compute/get_virtual_machine.rb, line 31
def get_vm_by_name(name, dc)
  vms = raw_list_all_virtual_machines(dc)
  vms.keep_if { |v| v["name"] == name }.first
end
get_vm_ref(id, dc = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_virtual_machine.rb, line 12
def get_vm_ref(id, dc = nil)
  raw_datacenter = find_raw_datacenter(dc) if dc
  vm = case is_uuid?(id)
         # UUID based
         when true
           params = {:uuid => id, :vmSearch => true, :instanceUuid => true}
           params[:datacenter] = raw_datacenter if dc
           @connection.searchIndex.FindByUuid(params)
         else
           # try to find based on VM name
           if dc
             get_vm_by_name(id, dc)
           else
             raw_datacenters.map { |d| get_vm_by_name(id, d["name"])}.compact.first
           end
       end
  vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
end
list_raw_resource_pools(cluster) click to toggle source

root ResourcePool + Children if they exists

# File lib/fog/vsphere/requests/compute/list_resource_pools.rb, line 17
def list_raw_resource_pools(cluster)
  [cluster.resourcePool, cluster.resourcePool.resourcePool].flatten
end
network_attributes(network, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_networks.rb, line 21
def network_attributes network, datacenter
  {
    :id         => managed_obj_id(network),
    :name       => network.name,
    :accessible => network.summary.accessible,
    :datacenter => datacenter,
  }
end
raw_datacenters(folder=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 26
def raw_datacenters folder=nil
  folder ||= @connection.rootFolder
  @raw_datacenters ||= get_raw_datacenters_from_folder folder
end
raw_getpathmo(mo) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 18
def raw_getpathmo mo
  if mo.parent == nil or mo.parent.name == @connection.rootFolder.name then
    [ mo.name ]
  else
    [ raw_getpathmo(mo.parent), mo.name ].flatten
  end
end
resource_pool_attributes(resource_pool, cluster, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_resource_pools.rb, line 21
def resource_pool_attributes resource_pool, cluster, datacenter
  {
    :id                   => managed_obj_id(resource_pool),
    :name                 => resource_pool.name,
    :configured_memory_mb => resource_pool.summary.configuredMemoryMB,
    :overall_status       => resource_pool.overallStatus,
    :cluster              => cluster,
    :datacenter           => datacenter
  }
end
server_type_attributes(servertype, datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_server_types.rb, line 28
def server_type_attributes(servertype, datacenter)
  {
    :id         => servertype.id,
    :name       => servertype.id,
    :family     => servertype.family,
    :fullname   => servertype.fullName,
    :datacenter => datacenter,
  }
end

Private Instance Methods

authenticate() click to toggle source
# File lib/fog/vsphere/compute.rb, line 438
def authenticate
  begin
    @connection.serviceContent.sessionManager.Login :userName => @vsphere_username,
                                                    :password => @vsphere_password
  rescue RbVmomi::VIM::InvalidLogin => e
    raise Fog::Vsphere::Errors::ServiceError, e.message
  end
end
connect() click to toggle source
# File lib/fog/vsphere/compute.rb, line 414
def connect
  # This is a state variable to allow digest validation of the SSL cert
  bad_cert = false
  loop do
    begin
      @connection = RbVmomi::VIM.new :host => @vsphere_server,
                                     :port => @vsphere_port,
                                     :path => @vsphere_path,
                                     :ns   => @vsphere_ns,
                                     :rev  => @vsphere_rev,
                                     :ssl  => @vsphere_ssl,
                                     :insecure => bad_cert
      break
    rescue OpenSSL::SSL::SSLError
      raise if bad_cert
      bad_cert = true
    end
  end

  if bad_cert then
    validate_ssl_connection
  end
end
controller_default_options() click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 105
def controller_default_options
  {:operation => "add", :type => RbVmomi::VIM.VirtualLsiLogicController.class, :key => 1000, :bus_id => 0, :shared => false }
end
controller_get_shared_from_options(options) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 109
def controller_get_shared_from_options options
  if (options.key? :shared and options[:shared]==false) or not options.key? :shared then
    :noSharing
  elsif options[:shared]==true then
    :virtualSharing
  elsif options[:shared].is_a? String
    options[:shared]
  else
    :noSharing
  end
end
create_controller(options=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 84
def create_controller options=nil
  options=if options
            controller_default_options.merge(Hash[options.map{|k,v| [k.to_sym,v] }])
          else
            controller_default_options
          end
  controller_class=if options[:type].is_a? String then
                     Fog::Vsphere.class_from_string options[:type], "RbVmomi::VIM"
                   else
                     options[:type]
                   end
  {
    :operation => options[:operation],
    :device    => controller_class.new({
      :key       => options[:key],
      :busNumber => options[:bus_id],
      :sharedBus => controller_get_shared_from_options(options),
    })
  }
end
create_disk(disk, index = 0, operation = :add, controller_key = 1000) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 121
def create_disk disk, index = 0, operation = :add, controller_key = 1000
  payload = {
    :operation     => operation,
    :fileOperation => operation == :add ? :create : :destroy,
    :device        => RbVmomi::VIM.VirtualDisk(
      :key           => disk.key || index,
      :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
        :fileName        => "[#{disk.datastore}]",
        :diskMode        => disk.mode.to_sym,
        :thinProvisioned => disk.thin
      ),
      :controllerKey => controller_key,
      :unitNumber    => index,
      :capacityInKB  => disk.size
    )
  }

  if operation == :add && disk.thin == 'false' && disk.eager_zero == 'true'
    payload[:device][:backing][:eagerlyScrub] = disk.eager_zero
  end

  payload
end
create_interface(nic, index = 0, operation = :add, attributes = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 69
def create_interface nic, index = 0, operation = :add, attributes = {}
  {
    :operation => operation,
    :device    => nic.type.new(
      :key         => index,
      :deviceInfo  =>
        {
          :label   => nic.name,
          :summary => nic.summary,
        },
      :backing     => create_nic_backing(nic, attributes),
      :addressType => 'generated')
  }
end
create_nic_backing(nic, attributes) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 54
def create_nic_backing nic, attributes
  raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)

  if raw_network.kind_of? RbVmomi::VIM::DistributedVirtualPortgroup
    RbVmomi::VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(
      :port => RbVmomi::VIM.DistributedVirtualSwitchPortConnection(
        :portgroupKey => raw_network.key,
        :switchUuid   => raw_network.config.distributedVirtualSwitch.uuid
      )
    )
  else
    RbVmomi::VIM.VirtualEthernetCardNetworkBackingInfo(:deviceName => nic.network)
  end
end
device_change(attributes) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 41
def device_change attributes
  devices = []
  if (nics = attributes[:interfaces])
    devices << nics.map { |nic| create_interface(nic, nics.index(nic), :add, attributes) }
  end

  if (disks = attributes[:volumes])
    devices << create_controller(attributes[:scsi_controller]||attributes["scsi_controller"]||{})
    devices << disks.map { |disk| create_disk(disk, disks.index(disk)) }
  end
  devices.flatten
end
extra_config(attributes) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 145
def extra_config attributes
  [
    {
      :key   => 'bios.bootOrder',
      :value => 'ethernet0'
    }
  ]
end
get_folder_path(folder, root = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 54
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
get_interface_from_options(vmid, options) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 27
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
list_all_templates(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_templates.rb, line 26
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
list_all_templates_in_folder(path, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_templates.rb, line 16
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
list_all_virtual_machines(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 32
def list_all_virtual_machines(options = { })
  raw_vms = raw_list_all_virtual_machines(options[:datacenter])
  vms = convert_vm_view_to_attr_hash(raw_vms)

  # remove all template based virtual machines
  vms.delete_if { |v| v['template'] }
  vms
end
list_all_virtual_machines_in_folder(path, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 23
def list_all_virtual_machines_in_folder(path, datacenter_name)
  folder = get_raw_vmfolder(path, datacenter_name)

  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
negotiate_revision(revision = nil) click to toggle source
# File lib/fog/vsphere/compute.rb, line 403
def negotiate_revision(revision = nil)
  # Negotiate the API revision
  if not revision
    rev = @connection.serviceContent.about.apiVersion
    @connection.rev = [ rev, ENV['FOG_VSPHERE_REV'] || '4.1' ].min
  end

  @vsphere_is_vcenter = @connection.serviceContent.about.apiType == "VirtualCenter"
  @vsphere_rev = @connection.rev
end
raw_list_all_virtual_machines(datacenter_name = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 41
def raw_list_all_virtual_machines(datacenter_name = nil)
  ## Moved this to its own function since trying to get a list of all virtual machines
  ## to parse for a find function took way too long. The raw list returned will make it
  ## much faster to interact for some functions.
  datacenters = find_datacenters(datacenter_name)
  datacenters.map do |dc|
    @connection.serviceContent.viewManager.CreateContainerView({
                                                                   :container  => dc.vmFolder,
                                                                   :type       =>  ["VirtualMachine"],
                                                                   :recursive  => true
                                                               }).view
  end.flatten
end
validate_ssl_connection() click to toggle source

Verify a SSL certificate based on the hashed public key

# File lib/fog/vsphere/compute.rb, line 448
def validate_ssl_connection
  pubkey = @connection.http.peer_cert.public_key
  pubkey_hash = Digest::SHA2.hexdigest(pubkey.to_s)
  expected_pubkey_hash = @vsphere_expected_pubkey_hash
  if pubkey_hash != expected_pubkey_hash then
    raise Fog::Vsphere::Errors::SecurityError, "The remote system presented a public key with hash #{pubkey_hash} but we're expecting a hash of #{expected_pubkey_hash || '<unset>'}.  If you are sure the remote system is authentic set vsphere_expected_pubkey_hash: <the hash printed in this message> in ~/.fog"
  end
end
vm_path_name(attributes) click to toggle source

this methods defines where the vm config files would be located, by default we prefer to keep it at the same place the (first) vmdk is located

# File lib/fog/vsphere/requests/compute/create_vm.rb, line 35
def vm_path_name attributes
  datastore = attributes[:volumes].first.datastore unless attributes[:volumes].empty?
  datastore ||= 'datastore1'
  "[#{datastore}]"
end