class Fog::Compute::Vsphere::Mock

rubocop:enable ClassLength

Public Class Methods

data() click to toggle source
# File lib/fog/vsphere/compute.rb, line 281
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'      => 8_388_608,
              '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'      => 10_485_762,
               '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' => 697_471_860_736,
          'accessible' => true,
          'capacity' => 1_099_243_192_320,
          'uncommitted' => 977_158_537_741,
          'cluster' => []
        },
        'datastore1' => {
          'id' => 'datastore-789123',
          'name' => 'datastore1',
          'datacenter' => 'Solutions',
          'type' => 'VMFS',
          'freespace' => 697_471_860_736,
          'accessible' => true,
          'capacity' => 1_099_243_192_320,
          'uncommitted' => 977_158_537_741,
          '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: 824_597_241_856,
          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 549
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 73
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 && 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' => {} }
  user_data = YAML.safe_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 306
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)
  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 = {})
  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)
  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 287
def create_vm(attributes = {})
  id = SecureRandom.uuid
  vm = {
    'id'                => id,
    'uuid'              => id,
    'instance_uuid'     => id,
    'mo_ref'            => "vm-#{rand 99_999}",
    'datacenter'        => attributes[:datacenter],
    'name'              => attributes[:name],
    'interfaces'        => attributes[:interfaces].map do
      {
        'mac' => 'f2:b5:46:b5:d8:d7'
      }
    end
  }
  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 559
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 = data[:groups][attributes[:name]]
  raise Fog::Vsphere::Error::NotFound unless group
  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 = data[:rules][attributes[:name]]
  raise Fog::Vsphere::Error::NotFound unless rule
  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 79
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 && 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)
  unless vms.empty?
    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)
  data[:clusters].find { |c| c[:name] == name && c[:datacenter] == datacenter_name } ||
    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: 33_504,
    totalMemory: 154_604_142_592,
    numCpuCores: 12,
    numCpuThreads: 24,
    effectiveCpu: 32_247,
    effectiveMemory: 135_733,
    numHosts: 1,
    numEffectiveHosts: 1,
    overallStatus: 'gray',
    overallCpuUsage: 15_682,
    overallMemoryUsage: 132_755,
    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 = 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)
  data[:folders].values.find { |f| (f['datacenter'] == datacenter_name) && f['path'].end_with?(path) } ||
    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 45
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 63
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)
  vm = if is_uuid?(id)
         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
         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 39
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 52
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 52
def list_compute_resources(_filters = {})
  [
    {
      id: 'domain-s7',
      name: 'fake-host',
      totalCpu: 33_504,
      totalMemory: 154_604_142_592,
      numCpuCores: 12,
      numCpuThreads: 24,
      effectiveCpu: 32_247,
      effectiveMemory: 135_733,
      numHosts: 1,
      numEffectiveHosts: 1,
      overallStatus: 'gray',
      overallCpuUsage: 15_682,
      overallMemoryUsage: 132_755,
      effective: true,
      isSingleHost: true
    }, {
      id: 'domain-s74',
      name: 'fake-cluster',
      totalCpu: 41_484,
      totalMemory: 51_525_996_544,
      numCpuCores: 12,
      numCpuThreads: 24,
      effectiveCpu: 37_796,
      effectiveMemory: 45_115,
      numHosts: 2,
      numEffectiveHosts: 2,
      overallStatus: 'gray',
      overallCpuUsage: 584,
      overallMemoryUsage: 26_422,
      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 = {})
  data[:datacenters].values
end
list_datastores(filters) click to toggle source
# File lib/fog/vsphere/requests/compute/list_datastores.rb, line 40
def list_datastores(filters)
  datacenter_name = filters[:datacenter]
  cluster_name = filters.fetch(:cluster, nil)
  if cluster_name.nil?
    data[:datastores].values.select { |d| d['datacenter'] == datacenter_name } ||
      raise(Fog::Compute::Vsphere::NotFound)
  else
    data[:datastores].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } ||
      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
  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 = {})
  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 93
def list_hosts(filters = {})
  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 105
def list_networks(filters)
  datacenter_name = filters[:datacenter]
  cluster_name = filters.fetch(:cluster, nil)
  if cluster_name.nil?
    data[:networks].values.select { |d| d['datacenter'] == datacenter_name } ||
      raise(Fog::Compute::Vsphere::NotFound)
  else
    data[:networks].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } ||
      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 = {})
  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 37
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)
    data[:storage_pods].select { |h| h[:datacenter] == filters[:datacenter] }
  else
    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 = data[:servers][options['instance_uuid']]
    server.nil? ? [] : [server]
  elsif options['mo_ref']
    data[:servers].values.select { |vm| vm['mo_ref'] == options['mo_ref'] }
  elsif options[:folder] && options[:datacenter]
    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
    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 26
def list_vm_cdroms(vm_id)
  raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless data[:servers].key?(vm_id)
  return [] unless data[:servers][vm_id].key?('cdroms')
  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 79
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 data[:servers].key?(vm_id)
  return [] unless data[:servers][vm_id].key?('scsi_controllers')
  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 56
def list_vm_volumes(vm_id); end
raw_clusters() click to toggle source
# File lib/fog/vsphere/requests/compute/list_clusters.rb, line 58
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 563
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)
  raise 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(_server) click to toggle source
# File lib/fog/vsphere/requests/compute/update_vm.rb, line 104
def update_vm(_server)
  # TODO: - currently useless and tests need to be re-though on a whole.
  { 'task_state' => 'success' }
end
update_vm_interface(_vmid, options = {}) click to toggle source
# File lib/fog/vsphere/requests/compute/modify_vm_interface.rb, line 85
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 829
def vm_clone(options = {})
  # Option handling TODO Needs better method of checking
  options = vm_clone_check_options(options)
  notfound = -> { 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']}")
  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'
  12_345
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.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