class Fog::Compute::Vsphere::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/vsphere/compute.rb, line 245
def self.data
  @data ||= Hash.new do |hash, key|
    hash[key] = {
      :servers => {
        "5032c8a5-9c5e-ba7a-3804-832a03e16381" => {
         "resource_pool"    => "Resources",
         "memory_mb"        => 2196,
         "mac_addresses"    => { "Network adapter 1" => "00:50:56:a9:00:28" },
         "power_state"      => "poweredOn",
         "cpus"             => 1,
         "hostname"         => "dhcp75-197.virt.bos.redhat.com",
         "mo_ref"           => "vm-562",
         "connection_state" => "connected",
         "overall_status"   => "green",
         "datacenter"       => "Solutions",
         "volumes"          =>
            [{
              "id"        => "6000C29c-a47d-4cd9-5249-c371de775f06",
              "datastore" => "Storage1",
              "mode"      => "persistent",
              "size"      => 8388608,
              "thin"      => true,
              "name"      => "Hard disk 1",
              "filename"  => "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
              "size_gb"   => 8
             }],
         "scsi_controllers" =>
            [{"shared_bus"  => "noSharing",
              "type"        => "VirtualLsiLogicController",
              "unit_number" => 7,
              "key"         => 1000
            }],
         "interfaces"       =>
            [{"mac"     => "00:50:56:a9:00:28",
              "network" => "dvportgroup-123456",
              "name"    => "Network adapter 1",
              "status"  => "ok",
              "summary" => "VM Network",
             }],
         "cdroms" =>
            [{
              "name"                => "CD-/DVD-Drive 1",
              "filename"            => nil,
              "key"                 => 3000,
              "controller_key"      => 200,
              "unit_number"         => 0,
              "start_connected"     => false,
              "allow_guest_control" => true,
              "connected"           => false,
             }],
         "hypervisor"       => "gunab.puppetlabs.lan",
         "guest_id"         => "rhel6_64Guest",
         "tools_state"      => "toolsOk",
         "cluster"          => "Solutionscluster",
         "name"             => "rhel64",
         "operatingsystem"  => "Red Hat Enterprise Linux 6 (64-bit)",
         "path"             => "/Datacenters/Solutions/vm",
         "uuid"             => "4229f0e9-bfdc-d9a7-7bac-12070772e6dc",
         "instance_uuid"    => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
         "id"               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
         "tools_version"    => "guestToolsUnmanaged",
         "ipaddress"        => "192.168.100.184",
         "template"         => false
        },
        "502916a3-b42e-17c7-43ce-b3206e9524dc" => {
         "resource_pool"    => "Resources",
         "memory_mb"        => 512,
         "power_state"      => "poweredOn",
         "mac_addresses"    => { "Network adapter 1" => "00:50:56:a9:00:00" },
         "hostname"         => nil,
         "cpus"             => 1,
         "connection_state" => "connected",
         "mo_ref"           => "vm-621",
         "overall_status"   => "green",
         "datacenter"       => "Solutions",
         "volumes"          =>
            [{"thin"      => false,
              "size_gb"   => 10,
              "datastore" => "datastore1",
              "filename"  => "[datastore1] i-1342439683/i-1342439683.vmdk",
              "size"      => 10485762,
              "name"      => "Hard disk 1",
              "mode"      => "persistent",
              "id"        => "6000C29b-f364-d073-8316-8e98ac0a0eae" }],
         "scsi_controllers" =>
            [{"shared_bus"  => "noSharing",
              "type"        => "VirtualLsiLogicController",
              "unit_number" => 7,
              "key"         => 1000
            }],
         "interfaces"       =>
            [{ "summary" => "VM Network",
              "mac"     => "00:50:56:a9:00:00",
              "status"  => "ok",
              "network" => "dvportgroup-123456",
              "name"    => "Network adapter 1" }],
         "hypervisor"       => "gunab.puppetlabs.lan",
         "guest_id"         => nil,
         "cluster"          => "Solutionscluster",
         "tools_state"      => "toolsNotInstalled",
         "name"             => "i-1342439683",
         "operatingsystem"  => nil,
         "path"             => "/",
         "tools_version"    => "guestToolsNotInstalled",
         "uuid"             => "4229e0de-30cb-ceb2-21f9-4d8d8beabb52",
         "instance_uuid"    => "502916a3-b42e-17c7-43ce-b3206e9524dc",
         "id"               => "502916a3-b42e-17c7-43ce-b3206e9524dc",
         "ipaddress"        => nil,
         "template"         => false
        },
        "5029c440-85ee-c2a1-e9dd-b63e39364603" => {
         "resource_pool"    => "Resources",
         "memory_mb"        => 2196,
         "power_state"      => "poweredOn",
         "mac_addresses"    => { "Network adapter 1" => "00:50:56:b2:00:af" },
         "hostname"         => "centos56gm.localdomain",
         "cpus"             => 1,
         "connection_state" => "connected",
         "mo_ref"           => "vm-715",
         "overall_status"   => "green",
         "datacenter"       => "Solutions",
         "hypervisor"       => "gunab.puppetlabs.lan",
         "guest_id"         => "rhel6_64Guest",
         "cluster"          => "Solutionscluster",
         "tools_state"      => "toolsOk",
         "name"             => "jefftest",
         "operatingsystem"  => "Red Hat Enterprise Linux 6 (64-bit)",
         "path"             => "/Solutions/wibble",
         "tools_version"    => "guestToolsUnmanaged",
         "ipaddress"        => "192.168.100.187",
         "uuid"             => "42329da7-e8ab-29ec-1892-d6a4a964912a",
         "instance_uuid"    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
         "id"               => "5029c440-85ee-c2a1-e9dd-b63e39364603",
         "template"         => false
        }
      },
      :datacenters => {
        "Solutions" => {:name => "Solutions", :status => "grey", :path => ['Solutions']}
      },
      :datastores => {
        'Storage1' => {
          'id' => 'datastore-123456',
          'name' => 'Storage1',
          'datacenter' => 'Solutions',
          'type' => 'VMFS',
          'freespace' => 697471860736,
          'accessible' => true,
          'capacity' => 1099243192320,
          'uncommitted' => 977158537741,
          'cluster' => [],
        },
        'datastore1' => {
          'id' => 'datastore-789123',
          'name' => 'datastore1',
          'datacenter' => 'Solutions',
          'type' => 'VMFS',
          'freespace' => 697471860736,
          'accessible' => true,
          'capacity' => 1099243192320,
          'uncommitted' => 977158537741,
          'cluster' => ['Solutionscluster'],
        },
      },
      :networks => {
        'network1' => {
          'id' => 'dvportgroup-123456',
          'name' => 'network1',
          'datacenter' => 'Solutions',
          'accessible' => true,
          'virtualswitch' => nil,
          'cluster' => ['Solutionscluster'],
        },
        'network2' => {
          'id' => 'dvportgroup-789123',
          'name' => 'network2',
          'datacenter' => 'Solutions',
          'accessible' => true,
          'virtualswitch' => nil,
          'cluster' => [],
        },
      },
      :folders => {
        'wibble' => {
          'name' => 'wibble',
          'datacenter' => 'Solutions',
          'path' => '/Solutions/wibble',
          'type' => 'vm'
        },
        'empty' => {
          'name' => 'empty',
          'datacenter' => 'Solutions',
          'path' => '/Solutions/empty',
          'type' => 'vm'
        }
      },
      :storage_pods =>
        [{:id => "group-p123456",
          :name => "Datastore Cluster 1",
          :freespace => "4856891834368",
          :capacity => "7132061630464",
          :datacenter => "Solutions",
         },
        ],
      :clusters =>
        [{:id => "1d4d9a3f-e4e8-4c40-b7fc-263850068fa4",
          :name => "Solutionscluster",
          :num_host => "4",
          :num_cpu_cores => "16",
          :overall_status => "green",
          :datacenter => "Solutions",
          :full_path => 'Solutionscluster',
          :klass => "RbVmomi::VIM::ComputeResource"
         },
         {:id => "e4195973-102b-4096-bbd6-5429ff0b35c9",
          :name => "Problemscluster",
          :num_host => "4",
          :num_cpu_cores => "32",
          :overall_status => "green",
          :datacenter => "Solutions",
          :full_path => 'Problemscluster',
          :klass => "RbVmomi::VIM::ComputeResource"
         },
         {
           :klass => "RbVmomi::VIM::Folder",
           :clusters => [{:id => "03616b8d-b707-41fd-b3b5-The first",
                          :name => "Problemscluster",
                          :num_host => "4",
                          :num_cpu_cores => "32",
                          :overall_status => "green",
                          :datacenter => "Solutions",
                          :full_path => 'Nested/Problemscluster',
                          :klass => "RbVmomi::VIM::ComputeResource"
                         },
                         {:id => "03616b8d-b707-41fd-b3b5-the Second",
                          :name => "Lastcluster",
                          :num_host => "8",
                          :num_cpu_cores => "32",
                          :overall_status => "green",
                          :datacenter => "Solutions",
                          :full_path => 'Nested/Lastcluster',
                          :klass => "RbVmomi::VIM::ComputeResource"}
           ]
         }
       ],
       :rules => {
         'anti-affinity-foo' => {
           :datacenter => 'Solutions',
           :cluster => 'Solutionscluster',
           :key => 4242,
           :name => 'anti-affinity-foo',
           :enabled => true,
           :type => RbVmomi::VIM::ClusterAntiAffinityRuleSpec,
           :vm_ids => ['5032c8a5-9c5e-ba7a-3804-832a03e16381', '502916a3-b42e-17c7-43ce-b3206e9524dc']
         }
       },
       :hosts => {
         'Host1' => {
           :datacenter => 'Solutions',
           :cluster => 'Solutionscluster',
           :name => 'host1.example.com',
           :model => 'PowerEdge R730',
           :vendor => 'Dell Inc.',
           :ipaddress => '1.2.3.4',
           :ipaddress6 => nil,
           :hostname => 'host1',
           :domainname => 'example.com',
           :product_name => 'VMware ESXi',
           :uuid => '4c4c4544-0051-3610-8046-c4c44f584a32',
           :cpu_cores => 20,
           :cpu_sockets => 2,
           :cpu_threads => 40,
           :memory => 824597241856,
           :product_version => '6.0.0',
           :vm_ids => ['5032c8a5-9c5e-ba7a-3804-832a03e16381', '502916a3-b42e-17c7-43ce-b3206e9524dc']
         }
       }
    }
  end
end
new(options={}) click to toggle source
# File lib/fog/vsphere/compute.rb, line 525
def initialize(options={})
  require 'rbvmomi'
  @vsphere_username = options[:vsphere_username]
  @vsphere_password = 'REDACTED'
  @vsphere_server   = options[:vsphere_server]
  @vsphere_expected_pubkey_hash = options[:vsphere_expected_pubkey_hash]
  @vsphere_is_vcenter = true
  @vsphere_rev = '4.0'
end

Public Instance Methods

add_vm_cdrom(cdrom) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_cdrom.rb, line 15
def add_vm_cdrom(cdrom)
  vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :add)]})
end
add_vm_controller(controller) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_controller.rb, line 11
def add_vm_controller(controller)
  vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(controller)]})
end
add_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 66
def add_vm_interface(vmid, options = {})
  raise ArgumentError, "instance id is a required parameter" unless vmid
  raise ArgumentError, "interface is a required parameter" unless options and options[:interface]
  true
end
add_vm_volume(volume) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_volume.rb, line 21
def add_vm_volume(volume)
  vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_cdrom(volume, :add)]})
end
cloudinit_to_customspec(user_data) click to toggle source
# File lib/fog/vsphere/requests/compute/cloudinit_to_customspec.rb, line 44
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['encryptionKey']                = user_data['encryptionKey'] if user_data.key?('encryptionKey')
  custom_spec['globalIPSettings']             = user_data['globalIPSettings'] if user_data.key?('globalIPSettings')
  custom_spec['identity']                     = user_data['identity'] if user_data.key?('identity')
  custom_spec['nicSettingMap']                = user_data['nicSettingMap'] if user_data.key?('nicSettingMap')
  custom_spec['options']                      = user_data['options'] if user_data.key?('options')
  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['ipsettings']['gateway']        =  user_data['gateway'] if user_data.key?('gateway')
  custom_spec['domain']                       =  user_data['domain'] if user_data.key?('domain')
  custom_spec['dnsSuffixList']                =  user_data['domainsuffixlist'] if user_data.key?('domainsuffixlist')
  custom_spec['time_zone']                    =  user_data['timezone'] if user_data.key?('timezone')
  custom_spec  
end
create_cdrom(cdrom, index = 0, operation = :add, controller_key = 200) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 308
def create_cdrom cdrom, index = 0, operation = :add, controller_key = 200
  {
    :operation     => operation,
    :device        => {
      :key           => cdrom.key || index,
      :backing       => { deviceName: '' },
      :controllerKey => controller_key,
      connectable: {
        startConnected: false,
        connected: false,
        allowGuestControl: true,
      },
    }
  }
end
create_folder(datacenter, path, name) click to toggle source
# File lib/fog/vsphere/requests/compute/create_folder.rb, line 19
def create_folder(datacenter, path, name)
  self.data[:folders][name] = {
    'name'       => name,
    'datacenter' => datacenter,
    'path'       => "#{path}/#{name}",
    'type'       => 'vm'
  }
end
create_group(attributes={}) click to toggle source
# File lib/fog/vsphere/requests/compute/create_group.rb, line 46
def create_group(attributes={})
  self.data[:groups][attributes[:name]] = attributes
end
create_rule(attributes={}) click to toggle source
# File lib/fog/vsphere/requests/compute/create_rule.rb, line 51
def create_rule(attributes={})
  attributes[:key] = rand(9999)
  self.data[:rules][attributes[:name]] = attributes
  attributes[:key]
end
create_vm(attributes = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/create_vm.rb, line 291
def create_vm attributes = { }
  id = SecureRandom.uuid
  vm = {
    'id'                => id,
    'uuid'              => id,
    'instance_uuid'     => id,
    'mo_ref'            => "vm-#{rand 99999}",
    'datacenter'        => attributes[:datacenter],
    'name'              => attributes[:name],
    'interfaces'        => attributes[:interfaces].map {{
      'mac' => 'f2:b5:46:b5:d8:d7'
    }}
  }
  self.data[:servers][id] = vm
  id
end
current_time() click to toggle source
# File lib/fog/vsphere/requests/compute/current_time.rb, line 12
def current_time
  { 'current_time' => Time.now.utc }
end
data() click to toggle source
# File lib/fog/vsphere/compute.rb, line 535
def data
  self.class.data[@vsphere_username]
end
destroy_group(attributes = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/destroy_group.rb, line 19
def destroy_group(attributes = {})
  group = self.data[:groups][attributes[:name]]
  raise Fog::Vsphere::Error::NotFound unless group
  self.data[:groups].delete(attributes[:name])
end
destroy_rule(attributes = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/destroy_rule.rb, line 19
def destroy_rule(attributes = {})
  rule = self.data[:rules][attributes[:name]]
  raise Fog::Vsphere::Error::NotFound unless rule
  self.data[:rules].delete(attributes[:name])
end
destroy_vm_cdrom(cdrom) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_cdrom.rb, line 19
def destroy_vm_cdrom(cdrom)
  vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :remove)]})
end
destroy_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 72
def destroy_vm_interface(vmid, options = {})
  raise ArgumentError, "instance id is a required parameter" unless vmid
  raise ArgumentError, "interface is a required parameter" unless options and options[:interface]
  true
end
destroy_vm_volume(volume) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_volume.rb, line 29
def destroy_vm_volume(volume)
  true
end
folder_destroy(path, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/folder_destroy.rb, line 16
def folder_destroy(path, datacenter_name)
  vms = list_virtual_machines(folder: path, datacenter: datacenter_name)
  if vms.length > 0
    raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty"
  end
  { 'task_state' => 'success' }
end
get_cluster(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_cluster.rb, line 20
def get_cluster(name, datacenter_name)
  self.data[:clusters].find {|c| c[:name] == name && c[:datacenter] == datacenter_name} or
    raise Fog::Compute::Vsphere::NotFound
end
get_compute_resource(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_compute_resource.rb, line 19
def get_compute_resource(name, datacenter_name)
  {
    :id=>"domain-s7", 
    :name=>"fake-host", 
    :totalCpu=>33504, 
    :totalMemory=>154604142592, 
    :numCpuCores=>12, 
    :numCpuThreads=>24, 
    :effectiveCpu=>32247, 
    :effectiveMemory=>135733, 
    :numHosts=>1, 
    :numEffectiveHosts=>1, 
    :overallStatus=>"gray", 
    :overallCpuUsage=>15682, 
    :overallMemoryUsage=>132755, 
    :effective=>true, 
    :isSingleHost=>true
  }
end
get_datacenter(name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datacenter.rb, line 23
def get_datacenter name
  dc = self.data[:datacenters][name]
  raise(Fog::Compute::Vsphere::NotFound) unless dc
  dc
end
get_datastore(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_datastore.rb, line 23
def get_datastore(name, datacenter_name)
end
get_folder(path, datacenter_name, type = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_folder.rb, line 73
def get_folder(path, datacenter_name, type = nil)
  self.data[:folders].values.find {|f| f['datacenter'] == datacenter_name and f['path'].end_with? path} or
    raise Fog::Compute::Vsphere::NotFound        
end
get_folder_path(folder, root = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 75
def get_folder_path(folder, root = nil)
  nil
end
get_network(id) click to toggle source
# File lib/fog/vsphere/requests/compute/get_network.rb, line 47
def get_network(id)
end
get_raw_clusters_from_folder(folder) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 66
def get_raw_clusters_from_folder(folder)
  folder.map do |child|
    if child[:klass] == 'RbVmomi::VIM::ComputeResource'
      child
    elsif child[:klass] == 'RbVmomi::VIM::Folder'
      get_raw_clusters_from_folder(child[:clusters])
    end
  end.flatten
end
get_resource_pool(name, cluster_name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_resource_pool.rb, line 21
def get_resource_pool(name, cluster_name, datacenter_name)
end
get_server_type(id) click to toggle source
# File lib/fog/vsphere/requests/compute/get_server_type.rb, line 22
def get_server_type(id)
  {:id=>"rhel6Guest",
    :name=>"rhel6Guest",
    :family=>"linuxGuest",
    :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
    :datacenter=>"Solutions"}
end
get_storage_pod(name, datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/get_storage_pod.rb, line 19
def get_storage_pod(name, datacenter_name)
  list_storage_pods({datacenter: datacenter_name}).detect { |h| h[:name] == name }
end
get_template(id, datacenter_name = nil) click to toggle source
# File lib/fog/vsphere/requests/compute/get_template.rb, line 11
def get_template(id, datacenter_name = nil)
end
get_virtual_machine(id, datacenter_name = nil, folder = nil, recursive = false) click to toggle source
# File lib/fog/vsphere/requests/compute/get_virtual_machine.rb, line 63
def get_virtual_machine(id, datacenter_name = nil, folder = nil, recursive = false)
  if is_uuid?(id)
    vm = list_virtual_machines({ 'instance_uuid' => id, 'datacenter' => datacenter_name }).first
  else
    # try to find based on VM name. May need to handle the path of the VM
    vm = list_virtual_machines({ 'name' => id, 'datacenter' => datacenter_name }).first
  end
  vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
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 21
def get_vm_first_scsi_controller(vm_id)
end
list_child_snapshots(snapshot, opts = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_child_snapshots.rb, line 41
def list_child_snapshots(snapshot, opts = {})
  [
    {
      :name => 'clean',
      :quiesced => false,
      :description => '',
      :create_time => Time.now.utc,
      :power_state => 'poweredOn',
      :ref => 'snapshot-0101',
      :mo_ref => nil,
      :tree_node => nil,
      :snapshot_name_chain => '123/clean',
      :ref_chain => '123/snap-0101'
    },
    {
      :name => 'dirty',
      :quiesced => false,
      :description => '',
      :create_time => Time.now.utc,
      :power_state => 'poweredOn',
      :ref => 'snapshot-0102',
      :mo_ref => nil,
      :tree_node => nil,
      :snapshot_name_chain => '123/dirty',
      :ref_chain => '123/snap-0102'
    }
  ]
end
list_clusters(*) click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 55
def list_clusters(*)
  raw_clusters.map do |cluster|
    cluster
  end
end
list_compute_resources(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_compute_resources.rb, line 54
def list_compute_resources(filters = { })
  [
    {
      :id=>"domain-s7", 
      :name=>"fake-host", 
      :totalCpu=>33504, 
      :totalMemory=>154604142592, 
      :numCpuCores=>12, 
      :numCpuThreads=>24, 
      :effectiveCpu=>32247, 
      :effectiveMemory=>135733, 
      :numHosts=>1, 
      :numEffectiveHosts=>1, 
      :overallStatus=>"gray", 
      :overallCpuUsage=>15682, 
      :overallMemoryUsage=>132755, 
      :effective=>true, 
      :isSingleHost=>true
    }, {
      :id=>"domain-s74", 
      :name=>"fake-cluster", 
      :totalCpu=>41484, 
      :totalMemory=>51525996544, 
      :numCpuCores=>12, 
      :numCpuThreads=>24, 
      :effectiveCpu=>37796, 
      :effectiveMemory=>45115, 
      :numHosts=>2, 
      :numEffectiveHosts=>2, 
      :overallStatus=>"gray", 
      :overallCpuUsage=>584, 
      :overallMemoryUsage=>26422, 
      :effective=>true, 
      :isSingleHost=>false
    }
  ]
end
list_datacenters(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datacenters.rb, line 47
def list_datacenters filters = {}
  self.data[:datacenters].values
end
list_datastores(filters) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datastores.rb, line 39
def list_datastores(filters)
  datacenter_name = filters[:datacenter]
  cluster_name = filters.fetch(:cluster, nil)
  if cluster_name.nil?
    self.data[:datastores].values.select { |d| d['datacenter'] == datacenter_name } or
      raise Fog::Compute::Vsphere::NotFound
  else
    self.data[:datastores].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } or
      raise Fog::Compute::Vsphere::NotFound
  end
end
list_folders(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_folders.rb, line 43
def list_folders(options = {})
  options.reject! {|k,v| v.nil? } # ignore options with nil value
  self.data[:folders].values.select {|folder| options.all? {|k,v| folder[k.to_s] == v.to_s }}
end
list_groups(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_groups.rb, line 24
def list_groups(filters = {})
  self.data[:groups].values.select {|g| g[:datacenter] == filters[:datacenter] && g[:cluster] == filters[:cluster]}
end
list_hosts(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_hosts.rb, line 77
def list_hosts(filters = {})
  self.data[:hosts].values.select {|r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster]}
end
list_networks(filters) click to toggle source
# File lib/fog/vsphere/requests/compute/list_networks.rb, line 67
def list_networks(filters)
  datacenter_name = filters[:datacenter]
  cluster_name = filters.fetch(:cluster, nil)
  if cluster_name.nil?
    self.data[:networks].values.select { |d| d['datacenter'] == datacenter_name } or
      raise Fog::Compute::Vsphere::NotFound
  else
    self.data[:networks].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } or
      raise Fog::Compute::Vsphere::NotFound
  end
end
list_processes(vm_id, opts = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_processes.rb, line 31
def list_processes(vm_id, opts = {})
  [
    Process.new(:name => 'winlogon'),
    Process.new(:name => 'init')
  ]
end
list_resource_pools(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_resource_pools.rb, line 53
def list_resource_pools(filters = { })
end
list_rules(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_rules.rb, line 31
def list_rules(filters = {})
  self.data[:rules].values.select {|r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster]}
end
list_server_types(datacenter_name) click to toggle source
# File lib/fog/vsphere/requests/compute/list_server_types.rb, line 39
def list_server_types(datacenter_name)
  [{:id=>"rhel6Guest",
    :name=>"rhel6Guest",
    :family=>"linuxGuest",
    :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
    :datacenter=>"Solutions"},
   {:id=>"rhel5_64Guest",
    :name=>"rhel5_64Guest",
    :family=>"linuxGuest",
    :fullname=>"Red Hat Enterprise Linux 5 (64-Bit)",
    :datacenter=>"Solutions"}]
end
list_storage_pods(filters = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_storage_pods.rb, line 31
def list_storage_pods(filters = {})
  if filters.key?(:datacenter)
    self.data[:storage_pods].select{|h| h[:datacenter] == filters[:datacenter] }
  else
    self.data[:storage_pods]
  end
end
list_templates(filters = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_templates.rb, line 39
def list_templates(filters = { })
end
list_virtual_machines(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/list_virtual_machines.rb, line 79
def list_virtual_machines(options = { })
  if options['instance_uuid']
    server = self.data[:servers][options['instance_uuid']]
    server.nil? ? [] : [server]
  elsif options['mo_ref']
    self.data[:servers].values.select{|vm| vm['mo_ref'] == options['mo_ref']}
  elsif options[:folder] and options[:datacenter]
    self.data[:servers].values.select {|vm| vm['path'] == options[:folder] && vm['datacenter'] == options[:datacenter]}
  else
    options.delete('datacenter') # real code iterates if this is missing
    options.reject! {|k,v| v.nil? } # ignore options with nil value
    self.data[:servers].values.select {|vm| options.all? {|k,v| vm[k.to_s] == v.to_s }}
  end
end
list_vm_cdroms(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_cdroms.rb, line 22
def list_vm_cdroms(vm_id)
  raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless self.data[:servers].key?(vm_id)
  return [] unless self.data[:servers][vm_id].key?('cdroms')
  self.data[:servers][vm_id]['cdroms'].map {|h| h.merge({:instance_uuid => vm_id}) }
end
list_vm_customfields() click to toggle source
# File lib/fog/vsphere/requests/compute/list_customfields.rb, line 16
def list_vm_customfields()
end
list_vm_interfaces(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_interfaces.rb, line 80
def list_vm_interfaces(vm_id)
end
list_vm_scsi_controllers(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_scsi_controllers.rb, line 23
def list_vm_scsi_controllers(vm_id)
  raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless self.data[:servers].key?(vm_id)
  return [] unless self.data[:servers][vm_id].key?('scsi_controllers')
  self.data[:servers][vm_id]['scsi_controllers'].map {|h| h.merge(:server_id => vm_id) }
end
list_vm_snapshots(vm_id, opts = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_snapshots.rb, line 40
def list_vm_snapshots(vm_id, opts = {})
  [
    {
      :name => 'clean',
      :quiesced => false,
      :description => '',
      :create_time => Time.now.utc,
      :power_state => 'poweredOn',
      :ref => 'snapshot-0101',
      :mo_ref => nil,
      :tree_node => nil,
      :snapshot_name_chain => '123/clean',
      :ref_chain => "#{vm_id}/snapshot-0101"
    },
    {
      :name => 'dirty',
      :quiesced => false,
      :description => '',
      :create_time => Time.now.utc,
      :power_state => 'poweredOn',
      :ref => 'snapshot-0102',
      :mo_ref => nil,
      :tree_node => nil,
      :snapshot_name_chain => '123/dirty',
      :ref_chain => "#{vm_id}/snapshot-0102"
    }
  ]
end
list_vm_volumes(vm_id) click to toggle source
# File lib/fog/vsphere/requests/compute/list_vm_volumes.rb, line 48
def list_vm_volumes(vm_id)
end
raw_clusters() click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 61
def raw_clusters
  folder = data[:clusters]
  @raw_clusters = get_raw_clusters_from_folder(folder)
end
remove_vm_volume(volume) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_volume.rb, line 25
def remove_vm_volume(volume)
  true
end
reset_data() click to toggle source
# File lib/fog/vsphere/compute.rb, line 539
def reset_data
  self.class.data.delete(@vsphere_username)
end
revert_to_snapshot(snapshot) click to toggle source
# File lib/fog/vsphere/requests/compute/revert_to_snapshot.rb, line 20
def revert_to_snapshot(snapshot)
  fail ArgumentError, 'snapshot is a required parameter' if snapshot.nil?

  {
    'state' => 'success'
  }
end
set_vm_customvalue(vm_id, key, value) click to toggle source
# File lib/fog/vsphere/requests/compute/set_vm_customvalue.rb, line 11
def set_vm_customvalue(vm_id, key, value)
  nil
end
update_vm_interface(vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 78
def update_vm_interface(vmid, options = {})
  return unless options[:interface]
  options[:interface].network = options[:network]
  options[:interface].type    = options[:type]
end
vm_acquire_ticket(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_acquire_ticket.rb, line 22
def vm_acquire_ticket(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key?('instance_uuid')
  {
    'ticket' => 'fdsfdsf',
    'host' => 'esxi.example.com',
    'port' => 443,
    'ssl_thumbprint' => '1C:63:E1:BD:56:03:EB:44:85:12:12:FC:DA:40:11:65:0E:30:A1:B8'
  }
end
vm_clone(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_clone.rb, line 826
def vm_clone(options = {})
  # Option handling TODO Needs better method of checking
  options = vm_clone_check_options(options)
  notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
  template = list_virtual_machines.find(notfound) do |vm|
    vm['name'] == options['template_path'].split("/")[-1]
  end

  # generate a random id
  id = [8,4,4,4,12].map{|i| Fog::Mock.random_hex(i)}.join("-")
  new_vm = template.clone.merge({
    "name" => options['name'],
    "id" => id,
    "instance_uuid" => id,
    "path" => "/Datacenters/#{options['datacenter']}/#{options['dest_folder'] ? options['dest_folder']+"/" : ""}#{options['name']}"
  })
  self.data[:servers][id] = new_vm

  {
    'vm_ref'   => "vm-#{Fog::Mock.random_numbers(3)}",
    'new_vm'   => new_vm,
    'task_ref' => "task-#{Fog::Mock.random_numbers(4)}",
  }
end
vm_config_vnc(options = { }) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_config_vnc.rb, line 34
def vm_config_vnc(options = { })
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_destroy(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_destroy.rb, line 16
def vm_destroy(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_execute(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_execute.rb, line 37
def vm_execute(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  raise ArgumentError, "command is a required parameter" unless options.key? 'command'
  raise ArgumentError, "user is a required parameter" unless options.key? 'user'
  raise ArgumentError, "password is a required parameter" unless options.key? 'password'
  return 12345
end
vm_get_vnc(uuid) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_config_vnc.rb, line 39
def vm_get_vnc uuid
  {:password => 'secret', :port => '5900', :enabled => 'true'}
end
vm_migrate(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_migrate.rb, line 34
def vm_migrate(options = {})
  priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_power_off(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_power_off.rb, line 27
def vm_power_off(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  vm = get_virtual_machine(options['instance_uuid'])
  vm["power_state"] = "poweredOff"
  {
    'task_state'     => "running",
    'power_off_type' => options['force'] ? 'cut_power' : 'shutdown_guest',
  }
end
vm_power_on(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_power_on.rb, line 19
def vm_power_on(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_reboot(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reboot.rb, line 24
def vm_reboot(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state'     => "running", 'reboot_type' => options['force'] ? 'reset_power' : 'reboot_guest' }
end
vm_reconfig_cdrom(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_cdrom.rb, line 37
def vm_reconfig_cdrom(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  if options.has_key?('iso')
    raise ArgumentError, "datastore is a required parameter" unless options.key? 'datastore'
    backing = {
      fileName: "[#{options['datastore']}] #{options['iso']}"
    }
  else
    backing = {deviceName: ''}
  end
  cdrom_obj = list_vm_cdroms(options['instance_uuid']).first
  hardware_spec = {
    deviceChange: [{
      operation: :edit,
      device: {
        backing: backing,
        key: cdrom_obj['key'],
        controllerKey: cdrom_obj['controllerKey'],
        connectable: {
          startConnected: options['start_connected'] || false,
          connected: options['connected'] || false,
          allowGuestControl: options['allow_guest_control'] || true,
        }
      }
    }]
  }
  vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
end
vm_reconfig_cpus(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_cpus.rb, line 14
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 16
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'
  { 'task_state' => 'success' }
end
vm_reconfig_memory(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_memory.rb, line 14
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
vm_reconfig_volumes(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_reconfig_volumes.rb, line 19
def vm_reconfig_volumes(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  raise ArgumentError, "volumes is a required parameter" unless options.key? 'volumes'
  hardware_spec = {
    deviceChange: []
  }
  options['volumes'].each do |volume|
    hardware_spec[:deviceChange].push({
      :operation=>:edit,
      device: {
        backing: { diskMode: volume.mode, fileName: volume.filename },
        unitNumber: volume.unit_number,
        key: volume.key,
        controllerKey: volume.controller_key,
        capacityInKB: volume.size,
      }
    })
  end
  vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
end
vm_relocate(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_relocate.rb, line 47
def vm_relocate(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_remove_snapshot(vm_id, snapshot_id) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_remove_snapshot.rb, line 20
def vm_remove_snapshot(vm_id, snapshot_id)
  {
    'task_state' => 'success',
    'was_cancelled' => false
  }
end
vm_rename(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_rename.rb, line 16
def vm_rename(options = {})
  raise ArgumentError, "name is a required parameter" unless options.key? 'name'
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  { 'task_state' => 'success' }
end
vm_revert_snapshot(vm_id, snapshot_id) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_revert_snapshot.rb, line 20
def vm_revert_snapshot(vm_id, snapshot_id)
  {
    'task_state' => 'success',
    'was_cancelled' => false
  }
end
vm_suspend(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_suspend.rb, line 40
def vm_suspend(options = {})
  raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'

  vm = get_virtual_machine(options['instance_uuid'])
  vm['power_state'] = 'suspended'

  {
    'task_state'   => 'running',
    'suspend_type' => options['force'] ? 'suspend' : 'standby_guest'
  }
end
vm_take_snapshot(options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/vm_take_snapshot.rb, line 26
def vm_take_snapshot(options = {})
  raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
  raise ArgumentError, "name is a required parameter" unless options.key? 'name'
  {
    'task_state' => 'success',
    'was_cancelled' => false
  }
end