def __init__(self, module, datacenter_name, cluster_name=None):
"""
Doctring: Init
"""
super(VmwareDrsGroupFactManager, self).__init__(module)
self.__datacenter_name = datacenter_name
self.__datacenter_obj = None
self.__cluster_name = cluster_name
self.__cluster_obj = None
self.__msg = 'Nothing to see here...'
self.__result = dict()
self.__changed = False
if datacenter_name:
datacenter_obj = find_datacenter_by_name(self.content, datacenter_name=datacenter_name)
self.cluster_obj_list = []
if datacenter_obj:
folder = datacenter_obj.hostFolder
self.cluster_obj_list = get_all_objs(self.content, [vim.ClusterComputeResource], folder)
else:
raise Exception("Datacenter '%s' not found" % self.__datacenter_name)
if cluster_name:
cluster_obj = self.find_cluster_by_name(cluster_name=self.__cluster_name)
if cluster_obj is None:
raise Exception("Cluster '%s' not found" % self.__cluster_name)
else:
self.cluster_obj_list = [cluster_obj]
def __init__(self, module):
super(VmwareDrsFactManager, self).__init__(module)
datacenter_name = self.params.get('datacenter', None)
if datacenter_name:
datacenter_obj = find_datacenter_by_name(
self.content, datacenter_name=datacenter_name)
self.cluster_obj_list = []
if datacenter_obj:
folder = datacenter_obj.hostFolder
self.cluster_obj_list = get_all_objs(
self.content, [vim.ClusterComputeResource], folder)
else:
self.module.fail_json(changed=False,
msg="Datacenter '%s' not found" %
datacenter_name)
cluster_name = self.params.get('cluster_name', None)
if cluster_name:
cluster_obj = self.find_cluster_by_name(cluster_name=cluster_name)
if cluster_obj is None:
self.module.fail_json(changed=False,
msg="Cluster '%s' not found" %
cluster_name)
else:
self.cluster_obj_list = [cluster_obj]
def find_dvspg_by_name(self):
vmware_distributed_port_group = get_all_objs(
self.content, [vim.dvs.DistributedVirtualPortgroup])
for dvspg in vmware_distributed_port_group:
if dvspg.name == self.dvportgroup_name:
return dvspg
return None
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(cluster_uuid=dict(required=False, type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
new_cluster_uuid = module.params['cluster_uuid']
try:
content = connect_to_api(module, False)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed, result, cluster_uuid = create_vsan_cluster(
host_system, new_cluster_uuid)
module.exit_json(changed=changed,
result=result,
cluster_uuid=cluster_uuid)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(vmk_name=dict(required=True, type='str'),
ip_address=dict(required=True, type='str'),
subnet_mask=dict(required=True, type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmk_name = module.params['vmk_name']
ip_address = module.params['ip_address']
subnet_mask = module.params['subnet_mask']
try:
content = connect_to_api(module, False)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed = configure_vmkernel_ip_address(host_system, vmk_name,
ip_address, subnet_mask)
module.exit_json(changed=changed)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(change_hostname_to=dict(required=True, type='str'),
domainname=dict(required=True, type='str'),
dns_servers=dict(required=True, type='list')))
module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
change_hostname_to = module.params['change_hostname_to']
domainname = module.params['domainname']
dns_servers = module.params['dns_servers']
try:
content = connect_to_api(module)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed = configure_dns(host_system, change_hostname_to, domainname, dns_servers)
module.exit_json(changed=changed)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def __init__(self, module):
super(VmwareDatastoreMaintenanceMgr, self).__init__(module)
datastore_name = self.params.get('datastore')
cluster_name = self.params.get('cluster_name')
datastore_cluster = self.params.get('datastore_cluster')
self.datastore_objs = []
if datastore_name:
ds = self.find_datastore_by_name(datastore_name=datastore_name)
if not ds:
self.module.fail_json(msg='Failed to find datastore "%(datastore)s".' % self.params)
self.datastore_objs = [ds]
elif cluster_name:
cluster = find_cluster_by_name(self.content, cluster_name)
if not cluster:
self.module.fail_json(msg='Failed to find cluster "%(cluster_name)s".' % self.params)
self.datastore_objs = cluster.datastore
elif datastore_cluster:
datastore_cluster_obj = get_all_objs(self.content, [vim.StoragePod])
if not datastore_cluster_obj:
self.module.fail_json(msg='Failed to find datastore cluster "%(datastore_cluster)s".' % self.params)
for datastore in datastore_cluster_obj.childEntity:
self.datastore_objs.append(datastore)
else:
self.module.fail_json(msg="Please select one of 'cluster_name', 'datastore' or 'datastore_cluster'.")
self.state = self.params.get('state')
def find_host_system(self):
if self.esxi_hostname:
host_system_obj = self.find_hostsystem_by_name(host_name=self.esxi_hostname)
if host_system_obj:
return host_system_obj
else:
self.module.fail_json(msg="Failed to find ESXi %s" % self.esxi_hostname)
host_system = get_all_objs(self.content, [vim.HostSystem])
return list(host_system)[0]
def find_dvs_by_uuid(self, uuid):
"""
Find DVS by UUID
Returns: DVS name
"""
dvs_list = get_all_objs(self.content, [vim.DistributedVirtualSwitch])
for dvs in dvs_list:
if dvs.uuid == uuid:
return dvs.summary.name
return None
def gather_rp_info(self):
resource_pool_info = []
rps = get_all_objs(self.content, [vim.ResourcePool])
for rp in rps:
tmp_info = dict(
name=rp.name,
cpu_allocation_reservation=rp.config.cpuAllocation.reservation,
cpu_allocation_expandable_reservation=rp.config.cpuAllocation.
expandableReservation,
cpu_allocation_limit=rp.config.cpuAllocation.limit,
cpu_allocation_shares=rp.config.cpuAllocation.shares.shares,
cpu_allocation_shares_level=rp.config.cpuAllocation.shares.
level,
cpu_allocation_overhead_limit=rp.config.cpuAllocation.
overheadLimit,
mem_allocation_reservation=rp.config.memoryAllocation.
reservation,
mem_allocation_expandable_reservation=rp.config.
memoryAllocation.expandableReservation,
mem_allocation_limit=rp.config.memoryAllocation.limit,
mem_allocation_shares=rp.config.memoryAllocation.shares.shares,
mem_allocation_shares_level=rp.config.memoryAllocation.shares.
level,
mem_allocation_overhead_limit=rp.config.memoryAllocation.
overheadLimit,
owner=rp.owner.name,
overall_status=rp.summary.runtime.overallStatus,
runtime_cpu_reservation_used=rp.summary.runtime.cpu.
reservationUsed,
runtime_cpu_reservation_used_vm=rp.summary.runtime.cpu.
reservationUsedForVm,
runtime_cpu_unreserved_for_pool=rp.summary.runtime.cpu.
unreservedForPool,
runtime_cpu_unreserved_for_vm=rp.summary.runtime.cpu.
unreservedForVm,
runtime_cpu_overall_usage=rp.summary.runtime.cpu.overallUsage,
runtime_cpu_max_usage=rp.summary.runtime.cpu.maxUsage,
runtime_memory_reservation_used=rp.summary.runtime.memory.
reservationUsed,
runtime_memory_reservation_used_vm=rp.summary.runtime.memory.
reservationUsedForVm,
runtime_memory_unreserved_for_pool=rp.summary.runtime.memory.
unreservedForPool,
runtime_memory_unreserved_for_vm=rp.summary.runtime.memory.
unreservedForVm,
runtime_memory_overall_usage=rp.summary.runtime.memory.
overallUsage,
runtime_memory_max_usage=rp.summary.runtime.memory.maxUsage,
)
resource_pool_info.append(tmp_info)
return resource_pool_info
def find_dvs_by_uuid(self, uuid=None):
"""Find DVS by it's UUID"""
dvs_obj = None
if uuid is None:
return dvs_obj
dvswitches = get_all_objs(self.content, [vim.DistributedVirtualSwitch])
for dvs in dvswitches:
if dvs.uuid == uuid:
dvs_obj = dvs
break
return dvs_obj
def select_resource_pool(self, host):
pool_obj = None
resource_pools = get_all_objs(self.content, [vim.ResourcePool])
pool_selections = self.get_obj([vim.ResourcePool],
self.resource_pool,
return_all=True)
if pool_selections:
for p in pool_selections:
if p in resource_pools:
pool_obj = p
break
return pool_obj
def get_folder(self, folder_name, folder_type, parent_folder=None, recurse=False):
"""
Get managed object of folder by name
Returns: Managed object of folder by name
"""
parent_folder = parent_folder or self.datacenter_folder_type[folder_type]
folder_objs = get_all_objs(self.content, [vim.Folder], parent_folder, recurse=recurse)
for folder in folder_objs:
if folder.name == folder_name:
return folder
return None
def get_all_objs(self, content, types, confine_to_datacenter=True):
""" Wrapper around get_all_objs to set datacenter context """
objects = get_all_objs(content, types)
if confine_to_datacenter:
if hasattr(objects, 'items'):
# resource pools come back as a dictionary
for k, v in tuple(objects.items()):
parent_dc = get_parent_datacenter(k)
if parent_dc.name != self.dc_name:
del objects[k]
else:
# everything else should be a list
objects = [x for x in objects if get_parent_datacenter(x).name == self.dc_name]
return objects
def __init__(self, module):
super(DVSPortgroupFactsManager, self).__init__(module)
self.dc_name = self.params['datacenter']
self.dvs_name = self.params['dvswitch']
datacenter = self.find_datacenter_by_name(self.dc_name)
if datacenter is None:
self.module.fail_json(msg="Failed to find the datacenter %s" % self.dc_name)
if self.dvs_name:
# User specified specific dvswitch name to gather information
dvsn = find_dvs_by_name(self.content, self.dvs_name)
if dvsn is None:
self.module.fail_json(msg="Failed to find the dvswitch %s" % self.dvs_name)
self.dvsls = [dvsn]
else:
# default behaviour, gather information about all dvswitches
self.dvsls = get_all_objs(self.content, [vim.DistributedVirtualSwitch], folder=datacenter.networkFolder)
def get_folder(self, datacenter_name, folder_name, folder_type, parent_folder=None):
"""
Get managed object of folder by name
Returns: Managed object of folder by name
"""
folder_objs = get_all_objs(self.content, [vim.Folder], parent_folder)
for folder in folder_objs:
if parent_folder:
if folder.name == folder_name and \
self.datacenter_folder_type[folder_type].childType == folder.childType:
return folder
else:
if folder.name == folder_name and \
self.datacenter_folder_type[folder_type].childType == folder.childType and \
folder.parent.parent.name == datacenter_name: # e.g. folder.parent.parent.name == /DC01/host/folder
return folder
return None
def sanitize_disk_inputs(self):
"""
Check correctness of disk input provided by user
Returns: A list of dictionary containing disk information
"""
disks_data = list()
if not self.desired_disks:
self.module.exit_json(changed=False,
msg="No disks provided for virtual"
" machine '%s' for management." %
self.vm.name)
for disk_index, disk in enumerate(self.desired_disks):
# Initialize default value for disk
current_disk = dict(disk_index=disk_index,
state='present',
destroy=True,
filename=None,
datastore_cluster=None,
datastore=None,
autoselect_datastore=True,
disk_unit_number=0,
scsi_controller=0,
disk_mode='persistent')
# Check state
if 'state' in disk:
if disk['state'] not in ['absent', 'present']:
self.module.fail_json(
msg="Invalid state provided '%s' for disk index [%s]."
" State can be either - 'absent', 'present'" %
(disk['state'], disk_index))
else:
current_disk['state'] = disk['state']
if current_disk['state'] == 'absent':
current_disk['destroy'] = disk['destroy']
elif current_disk['state'] == 'present':
# Select datastore or datastore cluster
if 'datastore' in disk:
if 'autoselect_datastore' in disk:
self.module.fail_json(
msg="Please specify either 'datastore' "
"or 'autoselect_datastore' for disk index [%s]" %
disk_index)
# Check if given value is datastore or datastore cluster
datastore_name = disk['datastore']
datastore_cluster = find_obj(self.content,
[vim.StoragePod],
datastore_name)
datastore = find_obj(self.content, [vim.Datastore],
datastore_name)
if datastore is None and datastore_cluster is None:
self.module.fail_json(
msg=
"Failed to find datastore or datastore cluster named '%s' "
"in given configuration." % disk['datastore'])
if datastore_cluster:
# If user specified datastore cluster, keep track of that for determining datastore later
current_disk['datastore_cluster'] = datastore_cluster
elif datastore:
current_disk['datastore'] = datastore
current_disk['autoselect_datastore'] = False
elif 'autoselect_datastore' in disk:
# Find datastore which fits requirement
datastores = get_all_objs(self.content, [vim.Datastore])
if not datastores:
self.module.fail_json(
msg="Failed to gather information about"
" available datastores in given datacenter.")
datastore = None
datastore_freespace = 0
for ds in datastores:
if ds.summary.freeSpace > datastore_freespace:
# If datastore field is provided, filter destination datastores
datastore = ds
datastore_freespace = ds.summary.freeSpace
current_disk['datastore'] = datastore
if 'datastore' not in disk and 'autoselect_datastore' not in disk and 'filename' not in disk:
self.module.fail_json(
msg="Either 'datastore' or 'autoselect_datastore' is"
" required parameter while creating disk for "
"disk index [%s]." % disk_index)
if 'filename' in disk:
current_disk['filename'] = disk['filename']
if [
x for x in disk.keys()
if x.startswith('size_') or x == 'size'
]:
# size, size_tb, size_gb, size_mb, size_kb
disk_size_parse_failed = False
if 'size' in disk:
size_regex = re.compile(
r'(\d+(?:\.\d+)?)([tgmkTGMK][bB])')
disk_size_m = size_regex.match(disk['size'])
if disk_size_m:
expected = disk_size_m.group(1)
unit = disk_size_m.group(2)
else:
disk_size_parse_failed = True
try:
if re.match(r'\d+\.\d+', expected):
# We found float value in string, let's typecast it
expected = float(expected)
else:
# We found int value in string, let's typecast it
expected = int(expected)
except (TypeError, ValueError, NameError):
disk_size_parse_failed = True
else:
# Even multiple size_ parameter provided by user,
# consider first value only
param = [
x for x in disk.keys() if x.startswith('size_')
][0]
unit = param.split('_')[-1]
disk_size = disk[param]
if isinstance(disk_size, (float, int)):
disk_size = str(disk_size)
try:
if re.match(r'\d+\.\d+', disk_size):
# We found float value in string, let's typecast it
expected = float(disk_size)
else:
# We found int value in string, let's typecast it
expected = int(disk_size)
except (TypeError, ValueError, NameError):
disk_size_parse_failed = True
if disk_size_parse_failed:
# Common failure
self.module.fail_json(
msg="Failed to parse disk size for disk index [%s],"
" please review value provided"
" using documentation." % disk_index)
disk_units = dict(tb=3, gb=2, mb=1, kb=0)
unit = unit.lower()
if unit in disk_units:
current_disk['size'] = expected * (1024**
disk_units[unit])
else:
self.module.fail_json(
msg=
"%s is not a supported unit for disk size for disk index [%s]."
" Supported units are ['%s']." %
(unit, disk_index, "', '".join(disk_units.keys())))
elif current_disk['filename'] is None:
# No size found but disk, fail
self.module.fail_json(
msg="No size, size_kb, size_mb, size_gb or size_tb"
" attribute found into disk index [%s] configuration."
% disk_index)
# Check SCSI controller key
if 'scsi_controller' in disk:
try:
temp_disk_controller = int(disk['scsi_controller'])
except ValueError:
self.module.fail_json(
msg="Invalid SCSI controller ID '%s' specified"
" at index [%s]" %
(disk['scsi_controller'], disk_index))
if temp_disk_controller not in range(0, 4):
# Only 4 SCSI controllers are allowed per VM
self.module.fail_json(
msg="Invalid SCSI controller ID specified [%s],"
" please specify value between 0 to 3 only." %
temp_disk_controller)
current_disk['scsi_controller'] = temp_disk_controller
else:
self.module.fail_json(
msg="Please specify 'scsi_controller' under disk parameter"
" at index [%s], which is required while creating disk." %
disk_index)
# Check for disk unit number
if 'unit_number' in disk:
try:
temp_disk_unit_number = int(disk['unit_number'])
except ValueError:
self.module.fail_json(
msg="Invalid Disk unit number ID '%s'"
" specified at index [%s]" %
(disk['unit_number'], disk_index))
if temp_disk_unit_number not in range(0, 16):
self.module.fail_json(
msg=
"Invalid Disk unit number ID specified for disk [%s] at index [%s],"
" please specify value between 0 to 15"
" only (excluding 7)." %
(temp_disk_unit_number, disk_index))
if temp_disk_unit_number == 7:
self.module.fail_json(
msg=
"Invalid Disk unit number ID specified for disk at index [%s],"
" please specify value other than 7 as it is reserved"
"for SCSI Controller" % disk_index)
current_disk['disk_unit_number'] = temp_disk_unit_number
else:
self.module.fail_json(
msg="Please specify 'unit_number' under disk parameter"
" at index [%s], which is required while creating disk." %
disk_index)
# Type of Disk
disk_type = disk.get('type', 'thick').lower()
if disk_type not in ['thin', 'thick', 'eagerzeroedthick']:
self.module.fail_json(
msg=
"Invalid 'disk_type' specified for disk index [%s]. Please specify"
" 'disk_type' value from ['thin', 'thick', 'eagerzeroedthick']."
% disk_index)
current_disk['disk_type'] = disk_type
# Mode of Disk
temp_disk_mode = disk.get('disk_mode', 'persistent').lower()
if temp_disk_mode not in [
'persistent', 'independent_persistent',
'independent_nonpersistent'
]:
self.module.fail_json(
msg=
"Invalid 'disk_mode' specified for disk index [%s]. Please specify"
" 'disk_mode' value from ['persistent', 'independent_persistent', 'independent_nonpersistent']."
% disk_index)
current_disk['disk_mode'] = temp_disk_mode
# SCSI Controller Type
scsi_contrl_type = disk.get('scsi_type', 'paravirtual').lower()
if scsi_contrl_type not in self.scsi_device_type.keys():
self.module.fail_json(
msg=
"Invalid 'scsi_type' specified for disk index [%s]. Please specify"
" 'scsi_type' value from ['%s']" %
(disk_index, "', '".join(self.scsi_device_type.keys())))
current_disk['scsi_type'] = scsi_contrl_type
if 'shares' in disk:
current_disk['shares'] = disk['shares']
if 'iolimit' in disk:
current_disk['iolimit'] = disk['iolimit']
disks_data.append(current_disk)
return disks_data
def find_vm_by_name(self):
virtual_machines = get_all_objs(self.content, [vim.VirtualMachine])
for vm in virtual_machines:
if vm.name == self.vm_name:
return vm
return None
def sanitize_network_params(self):
network_list = []
valid_state = ['new', 'present', 'absent']
if len(self.params['networks']) != 0:
for network in self.params['networks']:
if 'state' not in network or network['state'].lower(
) not in valid_state:
self.module.fail_json(
msg=
"Network adapter state not specified or invalid: '%s', valid values: "
"%s" % (network.get('state', ''), valid_state))
# add new network adapter but no name specified
if network['state'].lower(
) == 'new' and 'name' not in network and 'vlan' not in network:
self.module.fail_json(
msg=
"Please specify at least network name or VLAN name for adding new network adapter."
)
if network['state'].lower() == 'new' and 'mac' in network:
self.module.fail_json(
msg=
"networks.mac is used for vNIC reconfigure, but networks.state is set to 'new'."
)
if network['state'].lower(
) == 'present' and 'mac' not in network and 'label' not in network and 'device_type' not in network:
self.module.fail_json(
msg=
"Should specify 'mac', 'label' or 'device_type' parameter to reconfigure network adapter"
)
if 'connected' in network:
if not isinstance(network['connected'], bool):
self.module.fail_json(
msg=
"networks.connected parameter should be boolean.")
if network['state'].lower(
) == 'new' and not network['connected']:
network['start_connected'] = False
if 'start_connected' in network:
if not isinstance(network['start_connected'], bool):
self.module.fail_json(
msg=
"networks.start_connected parameter should be boolean."
)
if network['state'].lower(
) == 'new' and not network['start_connected']:
network['connected'] = False
# specified network does not exist
if 'name' in network and not self.network_exists_by_name(
network['name']):
self.module.fail_json(
msg="Network '%(name)s' does not exist." % network)
elif 'vlan' in network:
objects = get_all_objs(
self.content, [vim.dvs.DistributedVirtualPortgroup])
dvps = [
x for x in objects
if to_text(get_parent_datacenter(x).name) == to_text(
self.params['datacenter'])
]
for dvp in dvps:
if hasattr(dvp.config.defaultPortConfig, 'vlan') and \
isinstance(dvp.config.defaultPortConfig.vlan.vlanId, int) and \
str(dvp.config.defaultPortConfig.vlan.vlanId) == str(network['vlan']):
network['name'] = dvp.config.name
break
if 'dvswitch_name' in network and \
dvp.config.distributedVirtualSwitch.name == network['dvswitch_name'] and \
dvp.config.name == network['vlan']:
network['name'] = dvp.config.name
break
if dvp.config.name == network['vlan']:
network['name'] = dvp.config.name
break
else:
self.module.fail_json(
msg="VLAN '%(vlan)s' does not exist." % network)
if 'device_type' in network and network[
'device_type'] not in list(
self.nic_device_type.keys()):
self.module.fail_json(
msg="Device type specified '%s' is invalid. "
"Valid types %s " %
(network['device_type'],
list(self.nic_device_type.keys())))
if ('mac' in network and not is_mac(network['mac'])) or \
('manual_mac' in network and not is_mac(network['manual_mac'])):
self.module.fail_json(
msg=
"Device MAC address '%s' or manual set MAC address %s is invalid. "
"Please provide correct MAC address." %
(network['mac'], network['manual_mac']))
network_list.append(network)
return network_list
def get_virtual_machines(self):
"""
Get one/all virtual machines and related configurations information.
"""
folder = self.params.get('folder')
folder_obj = None
if folder:
folder_obj = self.content.searchIndex.FindByInventoryPath(folder)
if not folder_obj:
self.module.fail_json(msg="Failed to find folder specified by %(folder)s" % self.params)
vm_name = self.params.get('vm_name')
if vm_name:
virtual_machine = find_vm_by_name(self.content, vm_name=vm_name, folder=folder_obj)
if not virtual_machine:
self.module.fail_json(msg="Failed to find virtual machine %s" % vm_name)
else:
virtual_machines = [virtual_machine]
else:
virtual_machines = get_all_objs(self.content, [vim.VirtualMachine], folder=folder_obj)
_virtual_machines = []
for vm in virtual_machines:
_ip_address = ""
summary = vm.summary
if summary.guest is not None:
_ip_address = summary.guest.ipAddress
if _ip_address is None:
_ip_address = ""
_mac_address = []
all_devices = _get_vm_prop(vm, ('config', 'hardware', 'device'))
if all_devices:
for dev in all_devices:
if isinstance(dev, vim.vm.device.VirtualEthernetCard):
_mac_address.append(dev.macAddress)
net_dict = {}
vmnet = _get_vm_prop(vm, ('guest', 'net'))
if vmnet:
for device in vmnet:
net_dict[device.macAddress] = dict()
net_dict[device.macAddress]['ipv4'] = []
net_dict[device.macAddress]['ipv6'] = []
for ip_addr in device.ipAddress:
if "::" in ip_addr:
net_dict[device.macAddress]['ipv6'].append(ip_addr)
else:
net_dict[device.macAddress]['ipv4'].append(ip_addr)
esxi_hostname = None
esxi_parent = None
if summary.runtime.host:
esxi_hostname = summary.runtime.host.summary.config.name
esxi_parent = summary.runtime.host.parent
cluster_name = None
if esxi_parent and isinstance(esxi_parent, vim.ClusterComputeResource):
cluster_name = summary.runtime.host.parent.name
vm_attributes = dict()
if self.module.params.get('show_attribute'):
vm_attributes = self.get_vm_attributes(vm)
vm_tags = list()
if self.module.params.get('show_tag'):
vm_tags = self.get_tag_info(vm)
vm_folder = PyVmomi.get_vm_path(content=self.content, vm_name=vm)
datacenter = get_parent_datacenter(vm)
datastore_url = list()
datastore_attributes = ('name', 'url')
if vm.config.datastoreUrl:
for entry in vm.config.datastoreUrl:
datastore_url.append({key: getattr(entry, key) for key in dir(entry) if key in datastore_attributes})
virtual_machine = {
"guest_name": summary.config.name,
"guest_fullname": summary.config.guestFullName,
"power_state": summary.runtime.powerState,
"ip_address": _ip_address, # Kept for backward compatibility
"mac_address": _mac_address, # Kept for backward compatibility
"uuid": summary.config.uuid,
"vm_network": net_dict,
"esxi_hostname": esxi_hostname,
"datacenter": datacenter.name,
"cluster": cluster_name,
"attributes": vm_attributes,
"tags": vm_tags,
"folder": vm_folder,
"moid": vm._moId,
"datastore_url": datastore_url,
}
vm_type = self.module.params.get('vm_type')
is_template = _get_vm_prop(vm, ('config', 'template'))
if vm_type == 'vm' and not is_template:
_virtual_machines.append(virtual_machine)
elif vm_type == 'template' and is_template:
_virtual_machines.append(virtual_machine)
elif vm_type == 'all':
_virtual_machines.append(virtual_machine)
return _virtual_machines
