def test_filter_cluster(self):
self.mock_prop_host1['parent'] = vim.ClusterComputeResource('cluster')
self.mock_prop_host2['parent'] = vim.ClusterComputeResource('cluster')
self.mock_prop_host3['parent'] = vim.Datacenter('dc')
mock_get_cl_name = MagicMock(
side_effect=['fake_bad_cluster', 'fake_good_cluster'])
with patch('salt.utils.vmware.get_mors_with_properties',
MagicMock(return_value=self.mock_prop_hosts)):
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_cl_name):
res = salt.utils.vmware.get_hosts(
self.mock_si, datacenter_name='fake_datacenter',
cluster_name='fake_good_cluster', get_all_hosts=True)
self.assertEqual(mock_get_cl_name.call_count, 2)
self.assertEqual(res, [self.mock_host2])
def test_filter_cluster(self):
cluster1 = vim.ClusterComputeResource('fake_good_cluster')
cluster2 = vim.ClusterComputeResource('fake_bad_cluster')
# Mock cluster1.name and cluster2.name
cluster1._stub = MagicMock(InvokeAccessor=MagicMock(
return_value='fake_good_cluster'))
cluster2._stub = MagicMock(InvokeAccessor=MagicMock(
return_value='fake_bad_cluster'))
self.mock_prop_host1['parent'] = cluster2
self.mock_prop_host2['parent'] = cluster1
self.mock_prop_host3['parent'] = cluster1
with patch('salt.utils.vmware.get_mors_with_properties',
MagicMock(return_value=self.mock_prop_hosts)):
res = salt.utils.vmware.get_hosts(self.mock_si,
datacenter_name='fake_datacenter',
cluster_name='fake_good_cluster',
get_all_hosts=True)
self.assertEqual(res, [self.mock_host2, self.mock_host3])
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 cleanup_cluster(context):
"""Delete cluster after vcenter sample run"""
cluster1_name = context.testbed.config['CLUSTER1_NAME']
names = set([cluster1_name])
cluster_summaries = context.client.vcenter.Cluster.list(
Cluster.FilterSpec(names=names))
print("Found '{}' Clusters matching names {}".format(
len(cluster_summaries), ", ".join(["'{}'".format(n) for n in names])))
if len(cluster_summaries) < 1:
return
# Delete the cluster using the managed object
cluster = cluster_summaries[0].cluster
cluster_mo = vim.ClusterComputeResource(cluster, context.soap_stub)
print("Deleting Cluster '{}' ({})".format(cluster, cluster1_name))
task = cluster_mo.Destroy()
pyVim.task.WaitForTask(task)
def test_parse_host_props(self):
"""Test the parse_host_props_method."""
facts = {
'summary.hardware.numCpuCores': 12,
'summary.config.name': 'host1',
'summary.hardware.numCpuPkgs': 2,
'summary.hardware.numCpuThreads': 24
}
cluster = vim.ClusterComputeResource('domain-c7')
props = []
prop_parent = Mock()
prop_parent.name, prop_parent.val = 'parent', cluster
props.append(prop_parent)
for key in facts:
prop = Mock()
prop.name, prop.val = key, facts[key]
props.append(prop)
cluster_dict = {}
cluster_dict[str(cluster)] = {
'cluster.name': 'cluster1',
'cluster.datacenter': 'dc1',
}
expected_facts = {
'host.cluster': 'cluster1',
'host.datacenter': 'dc1',
'host.name': 'host1',
'host.cpu_cores': 12,
'host.cpu_count': 2,
'host.cpu_threads': 24
}
results = self.runner.parse_host_props(props, cluster_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 move_host_into_cluster_vim(context, host_name, cluster_name):
"""Use vim api to move host to another cluster"""
TIMEOUT = 30 # sec
host = context.testbed.entities['HOST_IDS'][host_name]
host_mo = vim.HostSystem(host, context.soap_stub)
# Move the host into the cluster
if not host_mo.runtime.inMaintenanceMode:
task = host_mo.EnterMaintenanceMode(TIMEOUT)
pyVim.task.WaitForTask(task)
print("Host '{}' ({}) in maintenance mode".format(host, host_name))
cluster = context.testbed.entities['CLUSTER_IDS'][cluster_name]
cluster_mo = vim.ClusterComputeResource(cluster, context.soap_stub)
task = cluster_mo.MoveInto([host_mo])
pyVim.task.WaitForTask(task)
print("Host '{}' ({}) moved into Cluster {} ({})".format(
host, host_name, cluster, cluster_name))
task = host_mo.ExitMaintenanceMode(TIMEOUT)
pyVim.task.WaitForTask(task)
print("Host '{}' ({}) out of maintenance mode".format(host, host_name))
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'],
}
def test_vmware_get_inventory():
content = mock.Mock()
# Compute case 1
host_1 = mock.Mock()
host_1._moId = 'host:1'
host_1.name = 'host-1'
folder_1 = mock.Mock()
folder_1.host = [host_1]
# Computer case 2
host_2 = mock.Mock()
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]
# 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 = mock.Mock()
datastore_2_folder.childEntity = [datastore_2]
datastore_2_folder.name = 'datastore2-folder'
data_center_1 = mock.Mock()
data_center_1.name = 'dc-1'
data_center_1.hostFolder.childEntity = [folder_1, folder_2]
data_center_1.datastoreFolder.childEntity = [
datastore_1, datastore_2_folder
]
content.rootFolder.childEntity = [data_center_1]
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,
)
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.ClusterComputeResource, 'name', None))
stack.enter_context(
mock.patch.object(vim.ClusterComputeResource, 'host', None))
stack.enter_context(mock.patch.object(vim.Datastore, 'name', None))
host, ds = collector._vmware_get_inventory(content)
assert host == {
'host:1': {
'name': 'host-1',
'dc': 'dc-1',
'cluster': '',
},
'host:2': {
'name': 'host-2',
'dc': 'dc-1',
'cluster': 'compute-cluster-1',
}
}
assert ds == {
'datastore-1': {
'dc': 'dc-1',
'ds_cluster': '',
},
'datastore-2': {
'dc': 'dc-1',
'ds_cluster': 'datastore2-folder',
}
}
