In Files

Parent

Class/Module Index [+]

Quicksearch

Fog::Compute::Vsphere::Real

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/vsphere/compute.rb, line 194
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

  @connection = nil
  # 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

  # Negotiate the API revision
  if not options[:vsphere_rev]
    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

  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 6
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
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" }.collect { |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],
    :files        => { :vmPathName => vm_path_name(attributes) },
    :numCPUs      => attributes[:cpus],
    :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 6
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 13
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
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_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}
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_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_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)
  convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
end
get_vm_interface(vm_id, options={}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_interfaces.rb, line 46
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
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_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 6
def list_datacenters filters = {}
  raw_datacenters.map do |dc|
    {
      :id => managed_obj_id(dc),
      :name => dc.name,
      :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_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_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
    [service.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,
      :mode => vol.backing.diskMode,
      :filename => vol.backing.fileName,
      :datastore => (vol.backing.datastore.name rescue(nil)),
      :size => vol.capacityInKB,
      :name => vol.deviceInfo.label
    }
  end
end
raw_clusters(datacenter) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 13
def raw_clusters(datacenter)
  find_raw_datacenter(datacenter).hostFolder.childEntity.grep(RbVmomi::VIM::ClusterComputeResource)
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
update_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 20
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
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 74
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

  # 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 = get_raw_vmfolder(options['dest_folder'], options['datacenter']) if options.has_key?('dest_folder')
  dest_folder ||= vm_mob_ref.parent

  # Options['resource_pool']<~Array>
  # Now find _a_ resource pool to use for the clone if one is not specified
  if ( options.has_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.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') )
    #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::VirtualE1000(
      :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
  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']
    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

  # 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
    # 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.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'],
                                 :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['wait'] then
    # REVISIT: It would be awesome to call a block passed to this
    # request to notify the application how far along in the process we
    # are.  I'm thinking of updating a progress bar, etc...
    new_vm = task.wait_for_completion
  else
    tries = 0
    new_vm = begin
      # Try and find the new VM (folder.find is quite efficient)
      folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
    rescue Fog::Vsphere::Errors::NotFound
      tries += 1
      if tries <= 10 then
        sleep 15
        retry
      end
      nil
    end
  end

  # Return hash
  {
    'vm_ref'        => new_vm ? new_vm._ref : nil,
    'new_vm'        => new_vm ? get_virtual_machine("#{options['dest_folder']}/#{options['name']}", options['datacenter']) : 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.has_key? 'instance_uuid'

  search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
  vm_mob_ref    = @connection.searchIndex.FindAllByUuid(search_filter).first
  task          = vm_mob_ref.ReconfigVM_Task(:spec => {
    :extraConfig => [
      { :key => 'RemoteDisplay.vnc.enabled',  :value => options[:enabled] ? 'true' : 'false' },
      { :key => 'RemoteDisplay.vnc.password', :value => options[:password].to_s },
      { :key => 'RemoteDisplay.vnc.port',     :value => options[:port].to_s || '5910' }
    ]
  })
  task.wait_for_completion
  { 'task_state' => task.info.state }
end
vm_destroy(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_destroy.rb, line 6
def vm_destroy(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_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 6
def vm_migrate(options = {})
  #priority is the only required option, and it has a sane default option.
  priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'

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

  unless vm_mob_ref.kind_of? RbVmomi::VIM::VirtualMachine
    raise Fog::Vsphere::Errors::NotFound,
      "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
  end
  task = vm_mob_ref.MigrateVM_Task(:pool => options['pool'], :host => options['host'], :priority => "#{priority}", :state => options['state'] )
  task.wait_for_completion
  { 'task_state' => task.info.state }
end
vm_power_off(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_power_off.rb, line 6
def vm_power_off(options = {})
  options = { 'force' => false }.merge(options)
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'

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

  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 6
def vm_power_on(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'

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

  task = vm_mob_ref.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 6
def vm_reboot(options = {})
  options = { 'force' => false }.merge(options)
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'

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

  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.has_key? 'cpus'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
  hardware_spec={'numCPUs' => options['cpus']}
  vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
end
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.has_key? 'hardware_spec'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_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.has_key? 'memory'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.has_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 19
def cluster_attributes cluster, datacenter_name
  {
    :id             => managed_obj_id(cluster),
    :name           => cluster.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
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,
    :datacenter => datacenter,
  }
end
find_datacenters(name=nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 22
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_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_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) click to toggle source
# File lib/fog/vsphere/requests/compute/get_network.rb, line 13
def get_raw_network(name, datacenter_name)
  dc = find_raw_datacenter(datacenter_name)

  @connection.serviceContent.viewManager.CreateContainerView({
    :container  => dc.networkFolder,
    :type       =>  ["Network"],
    :recursive  => true
  }).view.select{|n| n.name == name}.first
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)
  cluster.resourcePool.find name
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(/^\/?#{dc_root_folder_path}\/?/, '').split('/')

  return dc_root_folder if paths.empty?
  # Walk the tree resetting the folder pointer as we go
  paths.inject(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_ref(id, dc = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_virtual_machine.rb, line 11
def get_vm_ref(id, dc = nil)
  vm = case id
         # UUID based
         when /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
           @connection.searchIndex.FindByUuid :uuid => id, :vmSearch => true, :instanceUuid => true, :datacenter => dc
         else
           # try to find based on VM name
           if dc
             get_raw_datacenter(dc).find_vm(id)
           else
             raw_datacenters.map { |d| d.find_vm(id) }.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() click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 18
def raw_datacenters
  @raw_datacenters ||= @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
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

[Validate]

Generated with the Darkfish Rdoc Generator 2.