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 create_vm_folder(context, datacenter_name, folder_name):
"""Create vm folder in given datacenter"""
datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name]
datacenter_mo = vim.Datacenter(datacenter, context.soap_stub)
folder_mo = datacenter_mo.vmFolder.CreateFolder(folder_name)
print("Created Folder '{}' ({}) in Datacenter '{}' ({})".format(
folder_name, folder_mo._moId, datacenter_name, datacenter))
return folder_mo._moId
def get_vm_moid_by_vm_name(self, vm_name):
for datacenter in self.children:
self.dc_name = self.get_data_center_name(datacenter)
self.dc = vim.Datacenter(self.dc_name)
self.dc._stub = self.smart_connect._stub
for datastore in self.dc.datastore:
for instance in datastore.vm:
if instance.name == vm_name:
self.virtual_machine = instance
instance = str(instance)[1:-1].split(":")
print("moid = ", instance[1])
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 create_vdswitch(context, datacenter_name, vdswitch_name):
"""Create Distributed Switch in given datacenter"""
datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name]
datacenter_mo = vim.Datacenter(datacenter, context.soap_stub)
spec = vim.DistributedVirtualSwitch.CreateSpec()
spec.configSpec = vim.DistributedVirtualSwitch.ConfigSpec(
name=vdswitch_name)
task = datacenter_mo.networkFolder.CreateDistributedVirtualSwitch(spec)
pyVim.task.WaitForTask(task)
vdswitch_mo = task.info.result
print("Created Distributed Switch '{}' ({})".format(
vdswitch_name, vdswitch_mo._moId))
return vdswitch_mo._moId
def setup_cluster_vapi1(context):
"""Create a cluster from the Datacenter managed object."""
cluster1_name = context.testbed.config['CLUSTER1_NAME']
# Get the host folder for the Datacenter2 using the save identifier
datacenter_name = context.testbed.config['DATACENTER2_NAME']
datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name]
# Create a managed object from the datacenter identifier
datacenter_mo = vim.Datacenter(datacenter, context.soap_stub)
# Using pyvmomi to get the host folder on which to create the cluster
folder_mo = datacenter_mo.hostFolder
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()
