def test_parse_cluster_props(self):
"""Test the parse_cluster_props_method."""
datacenter = vim.Datacenter('datacenter-1')
folder = vim.Folder('group-h1')
parents_dict = {}
parents_dict[str(datacenter)] = {
'type': 'vim.Datacenter',
'name': 'dc1'
}
parents_dict[str(folder)] = {
'type': 'vim.Folder',
'parent': str(datacenter)
}
props = [
vim.DynamicProperty(name='name', val='cluster1'),
vim.DynamicProperty(name='parent', val=folder)
]
expected_facts = {
'cluster.name': 'cluster1',
'cluster.datacenter': 'dc1'
}
results = self.runner.parse_cluster_props(props, parents_dict)
self.assertEqual(results, expected_facts)
def test_retrieve_properties(self):
"""Test the retrieve_properties method."""
content = Mock()
content.rootFolder = vim.Folder('group-d1')
objects_first_page = [
vim.ObjectContent(obj=vim.Folder('group-d1'), ),
vim.ObjectContent(obj=vim.ClusterComputeResource('domain-c1'), ),
]
objects_second_page = [
vim.ObjectContent(obj=vim.HostSystem('host-1'), ),
vim.ObjectContent(obj=vim.VirtualMachine('vm-1'), ),
]
content.propertyCollector.RetrievePropertiesEx(ANY).token = '1'
content.propertyCollector.RetrievePropertiesEx(ANY).objects = \
objects_first_page
content.propertyCollector.ContinueRetrievePropertiesEx(ANY).token = \
None
content.propertyCollector.ContinueRetrievePropertiesEx(ANY).objects = \
objects_second_page
with patch.object(InspectTaskRunner, 'parse_parent_props') \
as mock_parse_parent_props, patch.object(InspectTaskRunner,
'parse_cluster_props') \
as mock_parse_cluster_props, patch.object(InspectTaskRunner,
'parse_host_props')\
as mock_parse_host_props, patch.object(InspectTaskRunner,
'parse_vm_props') \
as mock_parse_vm_props:
self.runner.retrieve_properties(content)
mock_parse_parent_props.assert_called_with(ANY, ANY)
mock_parse_cluster_props.assert_called_with(ANY, ANY)
mock_parse_host_props.assert_called_with(ANY, ANY)
mock_parse_vm_props.assert_called_with(ANY, ANY)
def test_parse_parent_props(self):
"""Test the parse_parent_props_method."""
obj = vim.ClusterComputeResource('domain-c7')
folder = vim.Folder('group-h1')
props = [
vim.DynamicProperty(name='name', val='cluster1'),
vim.DynamicProperty(name='parent', val=folder),
]
expected_facts = {
'type': 'vim.ClusterComputeResource',
'name': 'cluster1',
'parent': str(folder)
}
results = self.runner.parse_parent_props(obj, props)
self.assertEqual(results, expected_facts)
def test_get_vm_names(self):
"""Test the get vm names method."""
objects = [
vim.ObjectContent(
obj=vim.VirtualMachine('vm-1'),
propSet=[vim.DynamicProperty(name='name', val='vm1')]),
vim.ObjectContent(
obj=vim.VirtualMachine('vm-2'),
propSet=[vim.DynamicProperty(name='name', val='vm2')]),
]
content = Mock()
content.rootFolder = vim.Folder('group-d1')
content.propertyCollector.RetrievePropertiesEx(ANY).token = None
content.propertyCollector.RetrievePropertiesEx(ANY).objects = objects
vm_names = get_vm_names(content)
self.assertTrue(isinstance(vm_names, list))
self.assertEqual(vm_names, ['vm1', 'vm2'])
def setup_cluster_vapi2(context):
"""Create a cluster from the Folder managed object"""
cluster1_name = context.testbed.config['CLUSTER1_NAME']
# Get the host folder for the Datacenter2 using the folder query
datacenter_name = context.testbed.config['DATACENTER2_NAME']
datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name]
folder_summaries = context.client.vcenter.Folder.list(
Folder.FilterSpec(type=Folder.Type.HOST,
datacenters=set([datacenter])))
folder = folder_summaries[0].folder
# Create a managed object from the folder identifier
folder_mo = vim.Folder(folder, context.soap_stub)
cluster_mo = folder_mo.CreateClusterEx(cluster1_name,
vim.cluster.ConfigSpecEx())
print("Created Cluster '{}' ({})".format(cluster_mo._moId, cluster1_name))
context.testbed.entities['CLUSTER_IDS'] = {cluster1_name: cluster_mo._moId}
def run(self,
ids=None,
names=None,
datastores=None,
datastore_clusters=None,
resource_pools=None,
vapps=None,
hosts=None,
folders=None,
clusters=None,
datacenters=None,
virtual_switches=None,
no_recursion=False,
vsphere=None):
# TODO: food for thought. PowerCli contains additional
# parameters that are not present here for the folliwing reason:
# <server> - we may need to bring it in if we decide to have
# connections to more than 1 VC.
# <tag> - Tags in VC are not the same as tags you see in Web
# Client for the reason, that those tags are stored
# in Inventory Service only. PowerCli somehow can access
# it, from vSphere SDK there is no way.
self.establish_connection(vsphere)
props = ['config.guestFullName', 'name', 'runtime.powerState']
moid_to_vm = {}
# getting vms by their ids
vms_from_vmids = []
if ids:
vms_from_vmids = [
vim.VirtualMachine(moid, stub=self.si._stub) for moid in ids
]
GetVMs.__add_vm_properties_to_map_from_vm_array(
moid_to_vm, vms_from_vmids)
# getting vms by their names
vms_from_names = []
if names:
container = self.si_content.viewManager.CreateContainerView(
self.si_content.rootFolder, [vim.VirtualMachine], True)
for vm in container.view:
if vm.name in names:
vms_from_names.append(vm)
GetVMs.__add_vm_properties_to_map_from_vm_array(
moid_to_vm, vms_from_names)
# getting vms from datastore objects
vms_from_datastores = []
if datastores:
vim_datastores = [
vim.Datastore(moid, stub=self.si._stub) for moid in datastores
]
for ds in vim_datastores:
vms_from_datastores.extend(ds.vm)
GetVMs.__add_vm_properties_to_map_from_vm_array(
moid_to_vm, vms_from_datastores)
# getting vms from datastore cluster objects
vms_from_datastore_clusters = []
if datastore_clusters:
vim_datastore_clusters = [
vim.StoragePod(moid, stub=self.si._stub)
for moid in datastore_clusters
]
for ds_cl in vim_datastore_clusters:
for ds in ds_cl.childEntity:
vms_from_datastore_clusters.extend(ds.vm)
GetVMs.__add_vm_properties_to_map_from_vm_array(
moid_to_vm, vms_from_datastore_clusters)
# getting vms from virtual switch objects
vms_from_virtual_switches = []
if virtual_switches:
vim_virtual_switches = [
vim.DistributedVirtualSwitch(moid, stub=self.si._stub)
for moid in virtual_switches
]
for vswitch in vim_virtual_switches:
for pg in vswitch.portgroup:
vms_from_virtual_switches.extend(pg.vm)
GetVMs.__add_vm_properties_to_map_from_vm_array(
moid_to_vm, vms_from_virtual_switches)
# getting vms from containers (location param)
vms_from_containers = []
containers = []
if resource_pools:
containers += [
vim.ResourcePool(moid, stub=self.si._stub)
for moid in resource_pools
]
if vapps:
containers += [
vim.VirtualApp(moid, stub=self.si._stub) for moid in vapps
]
if hosts:
containers += [
vim.HostSystem(moid, stub=self.si._stub) for moid in hosts
]
if folders:
containers += [
vim.Folder(moid, stub=self.si._stub) for moid in folders
]
if clusters:
containers += [
vim.ComputeResource(moid, stub=self.si._stub)
for moid in clusters
]
if datacenters:
containers += [
vim.Datacenter(moid, stub=self.si._stub)
for moid in datacenters
]
for cont in containers:
objView = self.si_content.viewManager.CreateContainerView(
cont, [vim.VirtualMachine], not no_recursion)
tSpec = vim.PropertyCollector.TraversalSpec(
name='tSpecName',
path='view',
skip=False,
type=vim.view.ContainerView)
pSpec = vim.PropertyCollector.PropertySpec(all=False,
pathSet=props,
type=vim.VirtualMachine)
oSpec = vim.PropertyCollector.ObjectSpec(obj=objView,
selectSet=[tSpec],
skip=False)
pfSpec = vim.PropertyCollector.FilterSpec(
objectSet=[oSpec],
propSet=[pSpec],
reportMissingObjectsInResults=False)
retOptions = vim.PropertyCollector.RetrieveOptions()
retProps = self.si_content.propertyCollector.RetrievePropertiesEx(
specSet=[pfSpec], options=retOptions)
vms_from_containers += retProps.objects
while retProps.token:
retProps = self.si_content.propertyCollector.\
ContinueRetrievePropertiesEx(
token=retProps.token)
vms_from_containers += retProps.objects
objView.Destroy()
for vm in vms_from_containers:
if vm.obj._GetMoId() not in moid_to_vm:
moid_to_vm[vm.obj._GetMoId()] = {
"moid": vm.obj._GetMoId(),
"name": vm.propSet[1].val,
"os": vm.propSet[0].val,
"runtime.powerState": vm.propSet[2].val
}
return moid_to_vm.values()
def test_vmware_get_inventory():
content = mock.Mock(spec=vim.ServiceInstanceContent)
# Compute case 1
host_1 = mock.Mock(spec=vim.HostSystem)
host_1._moId = 'host:1'
host_1.name = 'host-1'
host_1.summary.config.name = 'host-1.'
folder_1 = mock.Mock(spec=vim.ComputeResource)
folder_1.host = [host_1]
# Computer case 2
host_2 = mock.Mock(spec=vim.HostSystem)
host_2._moId = 'host:2'
host_2.name = 'host-2'
host_2.summary.config.name = 'host-2.'
folder_2 = vim.ClusterComputeResource('computer-cluster:1')
folder_2.__dict__['name'] = 'compute-cluster-1'
folder_2.__dict__['host'] = [host_2]
# Folders case
host_3 = mock.Mock(spec=vim.HostSystem)
host_3._moId = 'host:3'
host_3.name = 'host-3'
host_3.summary.config.name = 'host-3.'
folder_3 = mock.Mock(spec=vim.ComputeResource)
folder_3.host = [host_3]
folder_4 = vim.Folder('folder:4')
folder_4.__dict__['name'] = 'folder-4'
folder_4.__dict__['childEntity'] = [folder_3]
folder_5 = vim.Folder('folder:5')
folder_5.__dict__['name'] = 'folder-5'
folder_5.__dict__['childEntity'] = [folder_4]
# Datastore case 1
datastore_1 = vim.Datastore('datastore:1')
datastore_1.__dict__['name'] = 'datastore-1'
# Datastore case 2
datastore_2 = vim.Datastore('datastore:2')
datastore_2.__dict__['name'] = 'datastore-2'
datastore_2_folder = vim.StoragePod('storagepod:1')
datastore_2_folder.__dict__['childEntity'] = [datastore_2]
datastore_2_folder.__dict__['name'] = 'datastore2-folder'
data_center_1 = mock.Mock(spec=vim.Datacenter)
data_center_1.name = 'dc-1'
data_center_1_hostfolder = mock.Mock(spec=vim.Folder)
data_center_1_hostfolder.childEntity = [folder_1, folder_2, folder_5]
data_center_1.hostFolder = data_center_1_hostfolder
dc1_datastoreFolder = mock.Mock(spec=vim.Folder)
dc1_datastoreFolder.childEntity = [datastore_1, datastore_2_folder]
data_center_1.datastoreFolder = dc1_datastoreFolder
rootFolder1 = mock.Mock(spec=vim.Folder)
rootFolder1.childEntity = [data_center_1]
content.rootFolder = rootFolder1
collect_only = {
'vms': True,
'vmguests': True,
'datastores': True,
'hosts': True,
'snapshots': True,
}
collector = VmwareCollector(
'127.0.0.1',
'root',
'password',
collect_only,
ignore_ssl=True,
)
collector.content = content
with contextlib.ExitStack() as stack:
# We have to disable the LazyObject magic on pyvmomi classes so that we can use them as fakes
stack.enter_context(mock.patch.object(vim.Folder, 'name', None))
stack.enter_context(mock.patch.object(vim.Folder, 'childEntity', None))
stack.enter_context(mock.patch.object(vim.ClusterComputeResource, 'name', None))
stack.enter_context(mock.patch.object(vim.ClusterComputeResource, 'host', None))
stack.enter_context(mock.patch.object(vim.Datastore, 'name', None))
stack.enter_context(mock.patch.object(vim.StoragePod, 'childEntity', None))
stack.enter_context(mock.patch.object(vim.StoragePod, 'name', None))
host = yield collector.host_labels
ds = yield collector.datastore_labels
assert host == {
'host:1': ['host-1', 'dc-1', ''],
'host:2': ['host-2', 'dc-1', 'compute-cluster-1'],
'host:3': ['host-3', 'dc-1', ''],
}
assert ds == {
'datastore-1': ['datastore-1', 'dc-1', ''],
'datastore-2': ['datastore-2', 'dc-1', 'datastore2-folder'],
}
